diff --git a/Modules/Core/files.cmake b/Modules/Core/files.cmake
index 2efe3c5dc2..88b8bb3e09 100644
--- a/Modules/Core/files.cmake
+++ b/Modules/Core/files.cmake
@@ -1,325 +1,328 @@
 file(GLOB_RECURSE H_FILES RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/include/*")
 
 set(CPP_FILES
   mitkCoreActivator.cpp
   mitkCoreObjectFactoryBase.cpp
   mitkCoreObjectFactory.cpp
   mitkCoreServices.cpp
   mitkException.cpp
 
   Algorithms/mitkBaseDataSource.cpp
   Algorithms/mitkClippedSurfaceBoundsCalculator.cpp
   Algorithms/mitkCompareImageDataFilter.cpp
   Algorithms/mitkConvert2Dto3DImageFilter.cpp
   Algorithms/mitkDataNodeSource.cpp
   Algorithms/mitkExtractSliceFilter.cpp
   Algorithms/mitkHistogramGenerator.cpp
   Algorithms/mitkImageChannelSelector.cpp
   Algorithms/mitkImageSliceSelector.cpp
   Algorithms/mitkImageSource.cpp
   Algorithms/mitkImageTimeSelector.cpp
   Algorithms/mitkImageToImageFilter.cpp
   Algorithms/mitkImageToSurfaceFilter.cpp
   Algorithms/mitkMultiComponentImageDataComparisonFilter.cpp
   Algorithms/mitkPlaneGeometryDataToSurfaceFilter.cpp
   Algorithms/mitkPointSetSource.cpp
   Algorithms/mitkPointSetToPointSetFilter.cpp
   Algorithms/mitkRGBToRGBACastImageFilter.cpp
   Algorithms/mitkSubImageSelector.cpp
   Algorithms/mitkSurfaceSource.cpp
   Algorithms/mitkSurfaceToImageFilter.cpp
   Algorithms/mitkSurfaceToSurfaceFilter.cpp
   Algorithms/mitkUIDGenerator.cpp
   Algorithms/mitkVolumeCalculator.cpp
 
   Controllers/mitkBaseController.cpp
   Controllers/mitkCallbackFromGUIThread.cpp
   Controllers/mitkCameraController.cpp
   Controllers/mitkCameraRotationController.cpp
   Controllers/mitkFocusManager.cpp
   Controllers/mitkLimitedLinearUndo.cpp
   Controllers/mitkOperationEvent.cpp
   Controllers/mitkPlanePositionManager.cpp
   Controllers/mitkProgressBar.cpp
   Controllers/mitkRenderingManager.cpp
   Controllers/mitkSliceNavigationController.cpp
   Controllers/mitkSlicesCoordinator.cpp
   Controllers/mitkSlicesRotator.cpp
   Controllers/mitkSlicesSwiveller.cpp
   Controllers/mitkStatusBar.cpp
   Controllers/mitkStepper.cpp
   Controllers/mitkTestManager.cpp
   Controllers/mitkUndoController.cpp
   Controllers/mitkVerboseLimitedLinearUndo.cpp
   Controllers/mitkVtkInteractorCameraController.cpp
   Controllers/mitkVtkLayerController.cpp
 
   DataManagement/mitkAbstractTransformGeometry.cpp
   DataManagement/mitkAnnotationProperty.cpp
   DataManagement/mitkApplicationCursor.cpp
   DataManagement/mitkApplyTransformMatrixOperation.cpp
   DataManagement/mitkBaseData.cpp
   DataManagement/mitkBaseGeometry.cpp
   DataManagement/mitkBaseProperty.cpp
   DataManagement/mitkChannelDescriptor.cpp
   DataManagement/mitkClippingProperty.cpp
   DataManagement/mitkColorProperty.cpp
   DataManagement/mitkDataNode.cpp
   DataManagement/mitkDataStorage.cpp
   DataManagement/mitkDisplayGeometry.cpp
   DataManagement/mitkEnumerationProperty.cpp
   DataManagement/mitkFloatPropertyExtension.cpp
   DataManagement/mitkGeometry3D.cpp
   DataManagement/mitkGeometryData.cpp
   DataManagement/mitkGeometryTransformHolder.cpp
   DataManagement/mitkGroupTagProperty.cpp
   DataManagement/mitkImageAccessorBase.cpp
   DataManagement/mitkImageCaster.cpp
   DataManagement/mitkImageCastPart1.cpp
   DataManagement/mitkImageCastPart2.cpp
   DataManagement/mitkImageCastPart3.cpp
   DataManagement/mitkImageCastPart4.cpp
   DataManagement/mitkImage.cpp
   DataManagement/mitkImageDataItem.cpp
   DataManagement/mitkImageDescriptor.cpp
   DataManagement/mitkImageReadAccessor.cpp
   DataManagement/mitkImageStatisticsHolder.cpp
   DataManagement/mitkImageVtkAccessor.cpp
   DataManagement/mitkImageVtkReadAccessor.cpp
   DataManagement/mitkImageVtkWriteAccessor.cpp
   DataManagement/mitkImageWriteAccessor.cpp
   DataManagement/mitkIntPropertyExtension.cpp
   DataManagement/mitkIPersistenceService.cpp
   DataManagement/mitkIPropertyAliases.cpp
   DataManagement/mitkIPropertyDescriptions.cpp
   DataManagement/mitkIPropertyExtensions.cpp
   DataManagement/mitkIPropertyFilters.cpp
+  DataManagement/mitkIPropertyPersistence.cpp
   DataManagement/mitkLandmarkProjectorBasedCurvedGeometry.cpp
   DataManagement/mitkLandmarkProjector.cpp
   DataManagement/mitkLevelWindow.cpp
   DataManagement/mitkLevelWindowManager.cpp
   DataManagement/mitkLevelWindowPreset.cpp
   DataManagement/mitkLevelWindowProperty.cpp
   DataManagement/mitkLine.cpp
   DataManagement/mitkLookupTable.cpp
   DataManagement/mitkLookupTableProperty.cpp
   DataManagement/mitkLookupTables.cpp # specializations of GenericLookupTable
   DataManagement/mitkMaterial.cpp
   DataManagement/mitkMemoryUtilities.cpp
   DataManagement/mitkModalityProperty.cpp
   DataManagement/mitkModeOperation.cpp
   DataManagement/mitkModifiedLock.cpp
   DataManagement/mitkNodePredicateAnd.cpp
   DataManagement/mitkNodePredicateBase.cpp
   DataManagement/mitkNodePredicateCompositeBase.cpp
   DataManagement/mitkNodePredicateData.cpp
   DataManagement/mitkNodePredicateDataType.cpp
   DataManagement/mitkNodePredicateDimension.cpp
   DataManagement/mitkNodePredicateFirstLevel.cpp
   DataManagement/mitkNodePredicateNot.cpp
   DataManagement/mitkNodePredicateOr.cpp
   DataManagement/mitkNodePredicateProperty.cpp
   DataManagement/mitkNodePredicateSource.cpp
   DataManagement/mitkNumericConstants.cpp
   DataManagement/mitkPlaneGeometry.cpp
   DataManagement/mitkPlaneGeometryData.cpp
   DataManagement/mitkPlaneOperation.cpp
   DataManagement/mitkPlaneOrientationProperty.cpp
   DataManagement/mitkPointOperation.cpp
   DataManagement/mitkPointSet.cpp
   DataManagement/mitkPointSetShapeProperty.cpp
   DataManagement/mitkProperties.cpp
   DataManagement/mitkPropertyAliases.cpp
   DataManagement/mitkPropertyDescriptions.cpp
   DataManagement/mitkPropertyExtension.cpp
   DataManagement/mitkPropertyExtensions.cpp
   DataManagement/mitkPropertyFilter.cpp
   DataManagement/mitkPropertyFilters.cpp
   DataManagement/mitkPropertyList.cpp
   DataManagement/mitkPropertyListReplacedObserver.cpp
   DataManagement/mitkPropertyObserver.cpp
+  DataManagement/mitkPropertyPersistence.cpp
+  DataManagement/mitkPropertyPersistenceInfo.cpp
   DataManagement/mitkProportionalTimeGeometry.cpp
   DataManagement/mitkRenderingModeProperty.cpp
   DataManagement/mitkResliceMethodProperty.cpp
   DataManagement/mitkRestorePlanePositionOperation.cpp
   DataManagement/mitkRotationOperation.cpp
   DataManagement/mitkShaderProperty.cpp
   DataManagement/mitkSlicedData.cpp
   DataManagement/mitkSlicedGeometry3D.cpp
   DataManagement/mitkSmartPointerProperty.cpp
   DataManagement/mitkStandaloneDataStorage.cpp
   DataManagement/mitkStateTransitionOperation.cpp
   DataManagement/mitkStringProperty.cpp
   DataManagement/mitkSurface.cpp
   DataManagement/mitkSurfaceOperation.cpp
   DataManagement/mitkThinPlateSplineCurvedGeometry.cpp
   DataManagement/mitkTimeGeometry.cpp
   DataManagement/mitkTransferFunction.cpp
   DataManagement/mitkTransferFunctionInitializer.cpp
   DataManagement/mitkTransferFunctionProperty.cpp
   DataManagement/mitkVector.cpp
   DataManagement/mitkVtkInterpolationProperty.cpp
   DataManagement/mitkVtkRepresentationProperty.cpp
   DataManagement/mitkVtkResliceInterpolationProperty.cpp
   DataManagement/mitkVtkScalarModeProperty.cpp
   DataManagement/mitkVtkVolumeRenderingProperty.cpp
   DataManagement/mitkWeakPointerProperty.cpp
 
   Interactions/mitkAction.cpp
   Interactions/mitkAffineInteractor.cpp
   Interactions/mitkBindDispatcherInteractor.cpp
   Interactions/mitkCoordinateSupplier.cpp
   Interactions/mitkCrosshairPositionEvent.cpp
   Interactions/mitkDataInteractor.cpp
   Interactions/mitkDispatcher.cpp
   Interactions/mitkDisplayCoordinateOperation.cpp
   Interactions/mitkDisplayInteractor.cpp
   Interactions/mitkDisplayPositionEvent.cpp
 # Interactions/mitkDisplayVectorInteractorLevelWindow.cpp # legacy, prob even now unneeded
 # Interactions/mitkDisplayVectorInteractorScroll.cpp
   Interactions/mitkEventConfig.cpp
   Interactions/mitkEvent.cpp
   Interactions/mitkEventDescription.cpp
   Interactions/mitkEventFactory.cpp
   Interactions/mitkEventMapper.cpp
   Interactions/mitkEventRecorder.cpp
   Interactions/mitkEventStateMachine.cpp
   Interactions/mitkGlobalInteraction.cpp
   Interactions/mitkInteractionEventConst.cpp
   Interactions/mitkInteractionEvent.cpp
   Interactions/mitkInteractionEventHandler.cpp
   Interactions/mitkInteractionEventObserver.cpp
   Interactions/mitkInteractionKeyEvent.cpp
   Interactions/mitkInteractionPositionEvent.cpp
   Interactions/mitkInteractor.cpp
   Interactions/mitkInternalEvent.cpp
   Interactions/mitkKeyEvent.cpp
   Interactions/mitkMouseDoubleClickEvent.cpp
   Interactions/mitkMouseModeSwitcher.cpp
   Interactions/mitkMouseMoveEvent.cpp
   Interactions/mitkMouseMovePointSetInteractor.cpp
   Interactions/mitkMousePressEvent.cpp
   Interactions/mitkMouseReleaseEvent.cpp
   Interactions/mitkMouseWheelEvent.cpp
   Interactions/mitkMoveBaseDataInteractor.cpp
   Interactions/mitkNodeDepententPointSetInteractor.cpp
   Interactions/mitkPointSetDataInteractor.cpp
   Interactions/mitkPointSetInteractor.cpp
   Interactions/mitkPositionEvent.cpp
   Interactions/mitkPositionTracker.cpp
   Interactions/mitkSinglePointDataInteractor.cpp
   Interactions/mitkState.cpp
   Interactions/mitkStateEvent.cpp
   Interactions/mitkStateMachineAction.cpp
   Interactions/mitkStateMachineCondition.cpp
   Interactions/mitkStateMachineContainer.cpp
   Interactions/mitkStateMachine.cpp
   Interactions/mitkStateMachineFactory.cpp
   Interactions/mitkStateMachineState.cpp
   Interactions/mitkStateMachineTransition.cpp
   Interactions/mitkTransition.cpp
   Interactions/mitkVtkEventAdapter.cpp
   Interactions/mitkVtkInteractorStyle.cxx
   Interactions/mitkWheelEvent.cpp
   Interactions/mitkXML2EventParser.cpp
 
   IO/mitkAbstractFileIO.cpp
   IO/mitkAbstractFileReader.cpp
   IO/mitkAbstractFileWriter.cpp
   IO/mitkCustomMimeType.cpp
   IO/mitkDicomSeriesReader.cpp
   IO/mitkDicomSeriesReaderService.cpp
   IO/mitkDicomSR_GantryTiltInformation.cpp
   IO/mitkDicomSR_ImageBlockDescriptor.cpp
   IO/mitkDicomSR_LoadDICOMRGBPixel4D.cpp
   IO/mitkDicomSR_LoadDICOMRGBPixel.cpp
   IO/mitkDicomSR_LoadDICOMScalar4D.cpp
   IO/mitkDicomSR_LoadDICOMScalar.cpp
   IO/mitkDicomSR_SliceGroupingResult.cpp
   IO/mitkFileReader.cpp
   IO/mitkFileReaderRegistry.cpp
   IO/mitkFileReaderSelector.cpp
   IO/mitkFileReaderWriterBase.cpp
   IO/mitkFileWriter.cpp
   IO/mitkFileWriterRegistry.cpp
   IO/mitkFileWriterSelector.cpp
   IO/mitkIFileIO.cpp
   IO/mitkIFileReader.cpp
   IO/mitkIFileWriter.cpp
   IO/mitkImageGenerator.cpp
   IO/mitkImageVtkLegacyIO.cpp
   IO/mitkImageVtkXmlIO.cpp
   IO/mitkIMimeTypeProvider.cpp
   IO/mitkIOConstants.cpp
   IO/mitkIOMimeTypes.cpp
   IO/mitkIOUtil.cpp
   IO/mitkItkImageIO.cpp
   IO/mitkItkLoggingAdapter.cpp
   IO/mitkLegacyFileReaderService.cpp
   IO/mitkLegacyFileWriterService.cpp
   IO/mitkLog.cpp
   IO/mitkMimeType.cpp
   IO/mitkMimeTypeProvider.cpp
   IO/mitkOperation.cpp
   IO/mitkPixelType.cpp
   IO/mitkPointSetReaderService.cpp
   IO/mitkPointSetWriterService.cpp
   IO/mitkRawImageFileReader.cpp
   IO/mitkStandardFileLocations.cpp
   IO/mitkSurfaceStlIO.cpp
   IO/mitkSurfaceVtkIO.cpp
   IO/mitkSurfaceVtkLegacyIO.cpp
   IO/mitkSurfaceVtkXmlIO.cpp
   IO/mitkVtkLoggingAdapter.cpp
 
   Rendering/mitkAbstractOverlayLayouter.cpp
   Rendering/mitkBaseRenderer.cpp
   #Rendering/mitkGLMapper.cpp Moved to deprecated LegacyGL Module
   Rendering/mitkGradientBackground.cpp
   Rendering/mitkImageVtkMapper2D.cpp
   Rendering/mitkIShaderRepository.cpp
   Rendering/mitkManufacturerLogo.cpp
   Rendering/mitkMapper.cpp
   Rendering/mitkOverlay.cpp
   Rendering/mitkOverlayManager.cpp
   Rendering/mitkPlaneGeometryDataMapper2D.cpp
   Rendering/mitkPlaneGeometryDataVtkMapper3D.cpp
   Rendering/mitkPointSetVtkMapper2D.cpp
   Rendering/mitkPointSetVtkMapper3D.cpp
   Rendering/mitkRenderWindowBase.cpp
   Rendering/mitkRenderWindow.cpp
   Rendering/mitkRenderWindowFrame.cpp
   #Rendering/mitkSurfaceGLMapper2D.cpp Moved to deprecated LegacyGL Module
   Rendering/mitkSurfaceVtkMapper2D.cpp
   Rendering/mitkSurfaceVtkMapper3D.cpp
   Rendering/mitkVtkEventProvider.cpp
   Rendering/mitkVtkMapper.cpp
   Rendering/mitkVtkOverlay2D.cpp
   Rendering/mitkVtkOverlay3D.cpp
   Rendering/mitkVtkOverlay.cpp
   Rendering/mitkVtkPropRenderer.cpp
   Rendering/mitkVtkWidgetRendering.cpp
   Rendering/vtkMitkLevelWindowFilter.cpp
   Rendering/vtkMitkRectangleProp.cpp
   Rendering/vtkMitkRenderProp.cpp
   Rendering/vtkMitkThickSlicesFilter.cpp
   Rendering/vtkNeverTranslucentTexture.cpp
 )
 
 set(RESOURCE_FILES
 Interactions/globalConfig.xml
 Interactions/DisplayInteraction.xml
 Interactions/DisplayConfig.xml
 Interactions/DisplayConfigPACS.xml
 Interactions/DisplayConfigPACSPan.xml
 Interactions/DisplayConfigPACSScroll.xml
 Interactions/DisplayConfigPACSZoom.xml
 Interactions/DisplayConfigPACSLevelWindow.xml
 Interactions/DisplayConfigMITK.xml
 Interactions/PointSet.xml
 Interactions/Legacy/StateMachine.xml
 Interactions/Legacy/DisplayConfigMITKTools.xml
 Interactions/PointSetConfig.xml
 
 mitkLevelWindowPresets.xml
 )
diff --git a/Modules/Core/include/mitkCoreServices.h b/Modules/Core/include/mitkCoreServices.h
index dbd712f011..932ca0acd0 100644
--- a/Modules/Core/include/mitkCoreServices.h
+++ b/Modules/Core/include/mitkCoreServices.h
@@ -1,179 +1,187 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef MITKCORESERVICES_H
 #define MITKCORESERVICES_H
 
 #include "MitkCoreExports.h"
 
 #include <mitkLogMacros.h>
 #include <mitkCommon.h>
 
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 #include <mitkServiceInterface.h>
 #include <usServiceReference.h>
 
 #include <cassert>
 
 namespace mitk {
 
 struct IMimeTypeProvider;
 struct IShaderRepository;
 class IPropertyAliases;
 class IPropertyDescriptions;
 class IPropertyExtensions;
 class IPropertyFilters;
+class IPropertyPersistence;
 
 /**
  * @brief Access MITK core services.
  *
  * This class can be used to conveniently access common
  * MITK Core service objects. Some getter methods where implementations
  * exist in the core library are guaranteed to return a non-NULL service object.
  *
  * To ensure that CoreServices::Unget() is called after the caller
  * has finished using a service object, you should use the CoreServicePointer
  * helper class which calls Unget() when it goes out of scope:
  *
  * \code
  * CoreServicePointer<IShaderRepository> shaderRepo(CoreServices::GetShaderRepository());
  * // Do something with shaderRepo
  * \endcode
  *
  * @see CoreServicePointer
  */
 class MITKCORE_EXPORT CoreServices
 {
 public:
 
   /**
    * @brief Get an IShaderRepository instance.
    * @param context The module context of the module getting the service.
    * @return A IShaderRepository instance which can be NULL.
    */
   static IShaderRepository* GetShaderRepository();
 
   /**
    * @brief Get an IPropertyAliases instance.
    * @param context The module context of the module getting the service.
    * @return A non-NULL IPropertyAliases instance.
    */
   static IPropertyAliases* GetPropertyAliases(us::ModuleContext* context = us::GetModuleContext());
 
   /**
    * @brief Get an IPropertyDescriptions instance.
    * @param context The module context of the module getting the service.
    * @return A non-NULL IPropertyDescriptions instance.
    */
   static IPropertyDescriptions* GetPropertyDescriptions(us::ModuleContext* context = us::GetModuleContext());
 
   /**
    * @brief Get an IPropertyExtensions instance.
    * @param context The module context of the module getting the service.
    * @return A non-NULL IPropertyExtensions instance.
    */
   static IPropertyExtensions* GetPropertyExtensions(us::ModuleContext* context = us::GetModuleContext());
 
   /**
    * @brief Get an IPropertyFilters instance.
    * @param context The module context of the module getting the service.
    * @return A non-NULL IPropertyFilters instance.
    */
   static IPropertyFilters* GetPropertyFilters(us::ModuleContext* context = us::GetModuleContext());
 
+  /**
+  * @brief Get an IPropertyPersistence instance.
+  * @param context The module context of the module getting the service.
+  * @return A non-NULL IPropertyPersistence instance.
+  */
+  static IPropertyPersistence* GetPropertyPersistence(us::ModuleContext* context = us::GetModuleContext());
+
   /**
    * @brief Get an IMimeTypeProvider instance.
    * @param context The module context of the module getting the service.
    * @return A non-NULL IMimeTypeProvider instance.
    */
   static IMimeTypeProvider* GetMimeTypeProvider(us::ModuleContext* context = us::GetModuleContext());
 
   /**
    * @brief Unget a previously acquired service instance.
    * @param service The service instance to be released.
    * @return \c true if ungetting the service was successful, \c false otherwise.
    */
   template<class S>
   static bool Unget(S* service, us::ModuleContext* context = us::GetModuleContext())
   {
     return Unget(context, us_service_interface_iid<S>(), service);
   }
 
 private:
 
   static bool Unget(us::ModuleContext* context, const std::string& interfaceId, void* service);
 
   // purposely not implemented
   CoreServices();
   CoreServices(const CoreServices&);
   CoreServices& operator=(const CoreServices&);
 };
 
 /**
  * @brief A RAII helper class for core service objects.
  *
  * This is class is intended for usage in local scopes; it calls
  * CoreServices::Unget(S*) in its destructor. You should not construct
  * multiple CoreServicePointer instances using the same service pointer,
  * unless it is retrieved by a new call to a CoreServices getter method.
  *
  * @see CoreServices
  */
 template<class S>
 class MITK_LOCAL CoreServicePointer
 {
 public:
 
   explicit CoreServicePointer(S* service)
     : m_service(service)
   {
     assert(m_service);
   }
 
   ~CoreServicePointer()
   {
     try
     {
       CoreServices::Unget(m_service);
     }
     catch (const std::exception& e)
     {
       MITK_ERROR << e.what();
     }
     catch (...)
     {
       MITK_ERROR << "Ungetting core service failed.";
     }
   }
 
   S* operator->() const
   {
     return m_service;
   }
 
 private:
 
   // purposely not implemented
   CoreServicePointer(const CoreServicePointer&);
   CoreServicePointer& operator=(const CoreServicePointer&);
 
   S* const m_service;
 };
 
 }
 
 #endif // MITKCORESERVICES_H
diff --git a/Modules/Core/include/mitkIPropertyPersistence.h b/Modules/Core/include/mitkIPropertyPersistence.h
new file mode 100644
index 0000000000..14a0abdf9d
--- /dev/null
+++ b/Modules/Core/include/mitkIPropertyPersistence.h
@@ -0,0 +1,73 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef mitkIPropertyPersistence_h
+#define mitkIPropertyPersistence_h
+
+#include <mitkPropertyPersistenceInfo.h>
+#include <mitkServiceInterface.h>
+
+namespace mitk
+{
+  /** \ingroup MicroServices_Interfaces
+    * \brief Interface of property persistence service
+    *
+    * This service allows you to manage persistence info for base data properties.
+    * Persistent properties will be saved if the file format supports custom key value pairs like the .nrrd file format.
+    */
+  class MITKCORE_EXPORT IPropertyPersistence
+  {
+  public:
+    virtual ~IPropertyPersistence();
+
+    /** \brief Add persistence info for a specific base data property.
+      *
+      * \param[in] propertyName Name of the property.
+      * \param[in] info Persistence info of the property.
+      * \param[in] overwrite Overwrite already existing persistence info.
+      * \return True if persistence info was added successfully.
+      */
+    virtual bool AddInfo(const std::string& propertyName, PropertyPersistenceInfo::Pointer info, bool overwrite = false) = 0;
+
+    /** \brief Get the persistence info for a specific base data property.
+      *
+      * \param[in] propertyName Name of the property.
+      * \return Property persistence info or null pointer if no persistence info is available.
+      */
+    virtual PropertyPersistenceInfo::Pointer GetInfo(const std::string& propertyName) = 0;
+
+    /** \brief Check if a specific base data property has persistence info.
+      *
+      * \param[in] propertyName Name of the property.
+      * \return True if the property has persistence info, false otherwise.
+      */
+    virtual bool HasInfo(const std::string& propertyName) = 0;
+
+    /** \brief Remove all persistence info.
+      */
+    virtual void RemoveAllInfos() = 0;
+
+    /** \brief Remove persistence info of a specific base data property.
+      *
+      * \param[in] propertyName Name of the property.
+      */
+    virtual void RemoveInfo(const std::string& propertyName) = 0;
+  };
+}
+
+MITK_DECLARE_SERVICE_INTERFACE(mitk::IPropertyPersistence, "org.mitk.IPropertyPersistence")
+
+#endif
diff --git a/Modules/Core/include/mitkPropertyPersistence.h b/Modules/Core/include/mitkPropertyPersistence.h
new file mode 100644
index 0000000000..fe15c5dd2d
--- /dev/null
+++ b/Modules/Core/include/mitkPropertyPersistence.h
@@ -0,0 +1,49 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef mitkPropertyPersistence_h
+#define mitkPropertyPersistence_h
+
+#include <mitkIPropertyPersistence.h>
+#include <map>
+
+namespace mitk
+{
+  class PropertyPersistence : public IPropertyPersistence
+  {
+  public:
+    PropertyPersistence();
+    ~PropertyPersistence();
+
+    bool AddInfo(const std::string& propertyName, PropertyPersistenceInfo::Pointer info, bool overwrite) override;
+    PropertyPersistenceInfo::Pointer GetInfo(const std::string& propertyName) override;
+    bool HasInfo(const std::string& propertyName) override;
+    void RemoveAllInfos() override;
+    void RemoveInfo(const std::string& propertyName) override;
+
+  private:
+    typedef std::map<std::string, PropertyPersistenceInfo::Pointer> InfoMap;
+    typedef InfoMap::const_iterator InfoMapConstIterator;
+    typedef InfoMap::iterator InfoMapIterator;
+
+    PropertyPersistence(const PropertyPersistence&);
+    PropertyPersistence& operator=(const PropertyPersistence&);
+
+    InfoMap m_Infos;
+  };
+}
+
+#endif
diff --git a/Modules/Core/include/mitkPropertyPersistenceInfo.h b/Modules/Core/include/mitkPropertyPersistenceInfo.h
new file mode 100644
index 0000000000..47ca2aa97c
--- /dev/null
+++ b/Modules/Core/include/mitkPropertyPersistenceInfo.h
@@ -0,0 +1,57 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef mitkPropertyPersistenceInfo_h
+#define mitkPropertyPersistenceInfo_h
+
+#include <mitkCommon.h>
+#include <itkObjectFactory.h>
+#include <MitkCoreExports.h>
+
+namespace mitk
+{
+  /** \brief Property persistence info.
+    */
+  class MITKCORE_EXPORT PropertyPersistenceInfo : public itk::LightObject
+  {
+  public:
+    mitkClassMacroItkParent(PropertyPersistenceInfo, itk::LightObject);
+    itkFactorylessNewMacro(Self)
+    itkCloneMacro(Self)
+    mitkNewMacro1Param(Self, const std::string&);
+
+    std::string GetKey() const;
+    void SetKey(const std::string& key);
+
+  protected:
+    /** \brief Constructor.
+      *
+      * \param[in] key Key used to save the property value as key value pair. If empty, the property name is used.
+      */
+    PropertyPersistenceInfo(const std::string& key = "");
+
+    virtual ~PropertyPersistenceInfo();
+
+  private:
+    PropertyPersistenceInfo(const Self& other);
+    Self& operator=(const Self& other);
+
+    struct Impl;
+    Impl* m_Impl;
+  };
+}
+
+#endif
diff --git a/Modules/Core/src/DataManagement/mitkIPropertyPersistence.cpp b/Modules/Core/src/DataManagement/mitkIPropertyPersistence.cpp
new file mode 100644
index 0000000000..1b95eead05
--- /dev/null
+++ b/Modules/Core/src/DataManagement/mitkIPropertyPersistence.cpp
@@ -0,0 +1,21 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include "mitkIPropertyPersistence.h"
+
+mitk::IPropertyPersistence::~IPropertyPersistence()
+{
+}
diff --git a/Modules/Core/src/DataManagement/mitkPropertyPersistence.cpp b/Modules/Core/src/DataManagement/mitkPropertyPersistence.cpp
new file mode 100644
index 0000000000..a439cb2b37
--- /dev/null
+++ b/Modules/Core/src/DataManagement/mitkPropertyPersistence.cpp
@@ -0,0 +1,74 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include <mitkPropertyPersistence.h>
+#include <algorithm>
+#include <utility>
+
+mitk::PropertyPersistence::PropertyPersistence()
+{
+}
+
+mitk::PropertyPersistence::~PropertyPersistence()
+{
+}
+
+bool mitk::PropertyPersistence::AddInfo(const std::string& propertyName, PropertyPersistenceInfo::Pointer info, bool overwrite)
+{
+  if (propertyName.empty())
+    return false;
+
+  auto ret = m_Infos.insert(std::make_pair(propertyName, info));
+
+  if (!ret.second && overwrite)
+  {
+    ret.first->second = info;
+    ret.second = true;
+  }
+
+  return ret.second;
+}
+
+mitk::PropertyPersistenceInfo::Pointer mitk::PropertyPersistence::GetInfo(const std::string& propertyName)
+{
+  if (!propertyName.empty())
+  {
+    InfoMapConstIterator iter = m_Infos.find(propertyName);
+
+    if (iter != m_Infos.cend())
+      return iter->second;
+  }
+
+  return nullptr;
+}
+
+bool mitk::PropertyPersistence::HasInfo(const std::string& propertyName)
+{
+  return !propertyName.empty()
+    ? m_Infos.find(propertyName) != m_Infos.cend()
+    : false;
+}
+
+void mitk::PropertyPersistence::RemoveAllInfos()
+{
+  m_Infos.clear();
+}
+
+void mitk::PropertyPersistence::RemoveInfo(const std::string& propertyName)
+{
+  if (!propertyName.empty())
+    m_Infos.erase(propertyName);
+}
diff --git a/Modules/Core/src/DataManagement/mitkPropertyPersistenceInfo.cpp b/Modules/Core/src/DataManagement/mitkPropertyPersistenceInfo.cpp
new file mode 100644
index 0000000000..5ad5254357
--- /dev/null
+++ b/Modules/Core/src/DataManagement/mitkPropertyPersistenceInfo.cpp
@@ -0,0 +1,57 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include <mitkPropertyPersistenceInfo.h>
+
+namespace mitk
+{
+  struct PropertyPersistenceInfo::Impl
+  {
+    explicit Impl(const std::string& key);
+    ~Impl();
+
+    std::string Key;
+  };
+
+  PropertyPersistenceInfo::Impl::Impl(const std::string& key)
+    : Key(key)
+  {
+  }
+
+  PropertyPersistenceInfo::Impl::~Impl()
+  {
+  }
+}
+
+mitk::PropertyPersistenceInfo::PropertyPersistenceInfo(const std::string& key)
+  : m_Impl(new Impl(key))
+{
+}
+
+mitk::PropertyPersistenceInfo::~PropertyPersistenceInfo()
+{
+  delete m_Impl;
+}
+
+std::string mitk::PropertyPersistenceInfo::GetKey() const
+{
+  return m_Impl->Key;
+}
+
+void mitk::PropertyPersistenceInfo::SetKey(const std::string& key)
+{
+  m_Impl->Key = key;
+}
diff --git a/Modules/Core/src/IO/mitkItkImageIO.cpp b/Modules/Core/src/IO/mitkItkImageIO.cpp
index f8f73dfeff..bd0e646085 100644
--- a/Modules/Core/src/IO/mitkItkImageIO.cpp
+++ b/Modules/Core/src/IO/mitkItkImageIO.cpp
@@ -1,492 +1,495 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 
 #include "mitkItkImageIO.h"
 
 #include <mitkImage.h>
 #include <mitkImageReadAccessor.h>
 #include <mitkCustomMimeType.h>
 #include <mitkIOMimeTypes.h>
+#include <mitkLocaleSwitch.h>
 
 #include <itkImage.h>
 #include <itkImageIOFactory.h>
 #include <itkImageFileReader.h>
 #include <itkImageIORegion.h>
 #include <itkMetaDataObject.h>
 
-#include <mitkLocaleSwitch.h>
-
+#include <algorithm>
 
 namespace mitk {
 
 ItkImageIO::ItkImageIO(const ItkImageIO& other)
   : AbstractFileIO(other)
   , m_ImageIO(dynamic_cast<itk::ImageIOBase*>(other.m_ImageIO->Clone().GetPointer()))
 {
 }
 
 std::vector<std::string> ItkImageIO::FixUpImageIOExtensions(const std::string& imageIOName)
 {
   std::vector<std::string> extensions;
   // Try to fix-up some known ITK image IO classes
   if (imageIOName == "GiplImageIO")
   {
     extensions.push_back("gipl");
     extensions.push_back("gipl.gz");
   }
   else if (imageIOName == "GDCMImageIO")
   {
     extensions.push_back("gdcm");
     extensions.push_back("dcm");
     extensions.push_back("DCM");
     extensions.push_back("dc3");
     extensions.push_back("DC3");
     extensions.push_back("ima");
     extensions.push_back("img");
   }
   else if (imageIOName == "PNGImageIO")
   {
     extensions.push_back("png");
     extensions.push_back("PNG");
   }
   else if (imageIOName == "StimulateImageIO")
   {
     extensions.push_back("spr");
   }
   else if (imageIOName == "HDF5ImageIO")
   {
     extensions.push_back("hdf");
     extensions.push_back("h4");
     extensions.push_back("hdf4");
     extensions.push_back("h5");
     extensions.push_back("hdf5");
     extensions.push_back("he4");
     extensions.push_back("he5");
     extensions.push_back("hd5");
   }
   else if (imageIOName == "GE4ImageIO" || imageIOName == "GE5ImageIO")
   {
     extensions.push_back("");
   }
 
   if (!extensions.empty())
   {
     MITK_DEBUG << "Fixing up known extensions for " << imageIOName;
   }
 
   return extensions;
 }
 
 ItkImageIO::ItkImageIO(itk::ImageIOBase::Pointer imageIO)
   : AbstractFileIO(Image::GetStaticNameOfClass())
   , m_ImageIO(imageIO)
 {
   if (m_ImageIO.IsNull() )
   {
     mitkThrow() << "ITK ImageIOBase argument must not be NULL";
   }
 
   this->AbstractFileReader::SetMimeTypePrefix(IOMimeTypes::DEFAULT_BASE_NAME() + ".image.");
 
   std::vector<std::string> readExtensions = m_ImageIO->GetSupportedReadExtensions();
 
   if (readExtensions.empty())
   {
     std::string imageIOName = m_ImageIO->GetNameOfClass();
     MITK_DEBUG << "ITK ImageIOBase " << imageIOName << " does not provide read extensions";
     readExtensions = FixUpImageIOExtensions(imageIOName);
   }
 
   CustomMimeType customReaderMimeType;
   customReaderMimeType.SetCategory("Images");
   for(std::vector<std::string>::const_iterator iter = readExtensions.begin(),
       endIter = readExtensions.end(); iter != endIter; ++iter)
   {
     std::string extension = *iter;
     if (!extension.empty() && extension[0] == '.')
     {
       extension.assign(iter->begin()+1, iter->end());
     }
     customReaderMimeType.AddExtension(extension);
   }
   this->AbstractFileReader::SetMimeType(customReaderMimeType);
 
   std::vector<std::string> writeExtensions = imageIO->GetSupportedWriteExtensions();
   if (writeExtensions.empty())
   {
     std::string imageIOName = imageIO->GetNameOfClass();
     MITK_DEBUG << "ITK ImageIOBase " << imageIOName << " does not provide write extensions";
     writeExtensions = FixUpImageIOExtensions(imageIOName);
   }
 
   if (writeExtensions != readExtensions)
   {
     CustomMimeType customWriterMimeType;
     customWriterMimeType.SetCategory("Images");
     for(std::vector<std::string>::const_iterator iter = writeExtensions.begin(),
         endIter = writeExtensions.end(); iter != endIter; ++iter)
     {
       std::string extension = *iter;
       if (!extension.empty() && extension[0] == '.')
       {
         extension.assign(iter->begin()+1, iter->end());
       }
       customWriterMimeType.AddExtension(extension);
     }
     this->AbstractFileWriter::SetMimeType(customWriterMimeType);
   }
 
   std::string description = std::string("ITK ") + imageIO->GetNameOfClass();
   this->SetReaderDescription(description);
   this->SetWriterDescription(description);
 
   this->RegisterService();
 }
 
 ItkImageIO::ItkImageIO(const CustomMimeType& mimeType, itk::ImageIOBase::Pointer imageIO, int rank)
   : AbstractFileIO(Image::GetStaticNameOfClass(), mimeType, std::string("ITK ") + imageIO->GetNameOfClass())
   , m_ImageIO(imageIO)
 {
   if (m_ImageIO.IsNull() )
   {
     mitkThrow() << "ITK ImageIOBase argument must not be NULL";
   }
 
   this->AbstractFileReader::SetMimeTypePrefix(IOMimeTypes::DEFAULT_BASE_NAME() + ".image.");
 
   if (rank)
   {
     this->AbstractFileReader::SetRanking(rank);
     this->AbstractFileWriter::SetRanking(rank);
   }
 
   this->RegisterService();
 }
 
 std::vector<BaseData::Pointer> ItkImageIO::Read()
 {
   std::vector<BaseData::Pointer> result;
 
   const std::string& locale = "C";
   const std::string& currLocale = setlocale( LC_ALL, NULL );
 
   if ( locale.compare(currLocale)!=0 )
   {
     try
     {
       setlocale(LC_ALL, locale.c_str());
     }
     catch(...)
     {
       MITK_INFO << "Could not set locale " << locale;
     }
   }
 
   Image::Pointer image = Image::New();
 
   const unsigned int MINDIM = 2;
   const unsigned int MAXDIM = 4;
 
   const std::string path = this->GetLocalFileName();
 
   MITK_INFO << "loading " << path << " via itk::ImageIOFactory... " << std::endl;
 
   // Check to see if we can read the file given the name or prefix
   if (path.empty())
   {
     mitkThrow() << "Empty filename in mitk::ItkImageIO ";
   }
 
   // Got to allocate space for the image. Determine the characteristics of
   // the image.
   m_ImageIO->SetFileName( path );
   m_ImageIO->ReadImageInformation();
 
   unsigned int ndim = m_ImageIO->GetNumberOfDimensions();
   if ( ndim < MINDIM || ndim > MAXDIM )
   {
     MITK_WARN << "Sorry, only dimensions 2, 3 and 4 are supported. The given file has " << ndim << " dimensions! Reading as 4D.";
     ndim = MAXDIM;
   }
 
   itk::ImageIORegion ioRegion( ndim );
   itk::ImageIORegion::SizeType ioSize = ioRegion.GetSize();
   itk::ImageIORegion::IndexType ioStart = ioRegion.GetIndex();
 
   unsigned int dimensions[ MAXDIM ];
   dimensions[ 0 ] = 0;
   dimensions[ 1 ] = 0;
   dimensions[ 2 ] = 0;
   dimensions[ 3 ] = 0;
 
   ScalarType spacing[ MAXDIM ];
   spacing[ 0 ] = 1.0f;
   spacing[ 1 ] = 1.0f;
   spacing[ 2 ] = 1.0f;
   spacing[ 3 ] = 1.0f;
 
   Point3D origin;
   origin.Fill(0);
 
   unsigned int i;
   for ( i = 0; i < ndim ; ++i )
   {
     ioStart[ i ] = 0;
     ioSize[ i ] = m_ImageIO->GetDimensions( i );
     if(i<MAXDIM)
     {
       dimensions[ i ] = m_ImageIO->GetDimensions( i );
       spacing[ i ] = m_ImageIO->GetSpacing( i );
       if(spacing[ i ] <= 0)
         spacing[ i ] = 1.0f;
     }
     if(i<3)
     {
       origin[ i ] = m_ImageIO->GetOrigin( i );
     }
   }
 
   ioRegion.SetSize( ioSize );
   ioRegion.SetIndex( ioStart );
 
   MITK_INFO << "ioRegion: " << ioRegion << std::endl;
   m_ImageIO->SetIORegion( ioRegion );
   void* buffer = new unsigned char[m_ImageIO->GetImageSizeInBytes()];
   m_ImageIO->Read( buffer );
 
   image->Initialize( MakePixelType(m_ImageIO), ndim, dimensions );
   image->SetImportChannel( buffer, 0, Image::ManageMemory );
 
   // access direction of itk::Image and include spacing
   mitk::Matrix3D matrix;
   matrix.SetIdentity();
   unsigned int j, itkDimMax3 = (ndim >= 3? 3 : ndim);
   for ( i=0; i < itkDimMax3; ++i)
     for( j=0; j < itkDimMax3; ++j )
       matrix[i][j] = m_ImageIO->GetDirection(j)[i];
 
   // re-initialize PlaneGeometry with origin and direction
   PlaneGeometry* planeGeometry = image->GetSlicedGeometry(0)->GetPlaneGeometry(0);
   planeGeometry->SetOrigin(origin);
   planeGeometry->GetIndexToWorldTransform()->SetMatrix(matrix);
 
   // re-initialize SlicedGeometry3D
   SlicedGeometry3D* slicedGeometry = image->GetSlicedGeometry(0);
   slicedGeometry->InitializeEvenlySpaced(planeGeometry, image->GetDimension(2));
   slicedGeometry->SetSpacing(spacing);
 
   MITK_INFO << slicedGeometry->GetCornerPoint(false,false,false);
   MITK_INFO << slicedGeometry->GetCornerPoint(true,true,true);
 
   // re-initialize TimeGeometry
   ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
   timeGeometry->Initialize(slicedGeometry, image->GetDimension(3));
   image->SetTimeGeometry(timeGeometry);
 
   buffer = NULL;
   MITK_INFO << "number of image components: "<< image->GetPixelType().GetNumberOfComponents() << std::endl;
 
   const itk::MetaDataDictionary& dictionary = m_ImageIO->GetMetaDataDictionary();
   for (itk::MetaDataDictionary::ConstIterator iter = dictionary.Begin(), iterEnd = dictionary.End();
        iter != iterEnd; ++iter)
   {
-    std::string key = std::string("meta.") + iter->first;
     if (iter->second->GetMetaDataObjectTypeInfo() == typeid(std::string))
     {
+      std::string key = iter->first;
       std::string value = dynamic_cast<itk::MetaDataObject<std::string>*>(iter->second.GetPointer())->GetMetaDataObjectValue();
+
+      std::replace(key.begin(), key.end(), '_', '.');
+
       image->SetProperty(key.c_str(), mitk::StringProperty::New(value));
     }
   }
 
   MITK_INFO << "...finished!" << std::endl;
 
   try
   {
     setlocale(LC_ALL, currLocale.c_str());
   }
   catch(...)
   {
     MITK_INFO << "Could not reset locale " << currLocale;
   }
 
   result.push_back(image.GetPointer());
   return result;
 }
 
 AbstractFileIO::ConfidenceLevel ItkImageIO::GetReaderConfidenceLevel() const
 {
   return m_ImageIO->CanReadFile(GetLocalFileName().c_str()) ? IFileReader::Supported : IFileReader::Unsupported;
 }
 
 void ItkImageIO::Write()
 {
   const mitk::Image* image = dynamic_cast<const mitk::Image*>(this->GetInput());
 
   if (image == NULL)
   {
     mitkThrow() << "Cannot write non-image data";
   }
 
 
   // Switch the current locale to "C"
   LocaleSwitch localeSwitch("C");
 
   // Clone the image geometry, because we might have to change it
   // for writing purposes
   BaseGeometry::Pointer geometry = image->GetGeometry()->Clone();
 
   // Check if geometry information will be lost
   if (image->GetDimension() == 2 &&
       !geometry->Is2DConvertable())
   {
     MITK_WARN << "Saving a 2D image with 3D geometry information. Geometry information will be lost! You might consider using Convert2Dto3DImageFilter before saving.";
 
     // set matrix to identity
     mitk::AffineTransform3D::Pointer affTrans = mitk::AffineTransform3D::New();
     affTrans->SetIdentity();
     mitk::Vector3D spacing = geometry->GetSpacing();
     mitk::Point3D origin = geometry->GetOrigin();
     geometry->SetIndexToWorldTransform(affTrans);
     geometry->SetSpacing(spacing);
     geometry->SetOrigin(origin);
   }
 
   LocalFile localFile(this);
   const std::string path = localFile.GetFileName();
 
   MITK_INFO << "Writing image: " << path << std::endl;
 
   try
   {
     // Implementation of writer using itkImageIO directly. This skips the use
     // of templated itkImageFileWriter, which saves the multiplexing on MITK side.
 
     const unsigned int dimension = image->GetDimension();
     const unsigned int* const dimensions = image->GetDimensions();
     const mitk::PixelType pixelType = image->GetPixelType();
     const mitk::Vector3D mitkSpacing = geometry->GetSpacing();
     const mitk::Point3D mitkOrigin = geometry->GetOrigin();
 
     // Due to templating in itk, we are forced to save a 4D spacing and 4D Origin,
     // though they are not supported in MITK
     itk::Vector<double, 4u> spacing4D;
     spacing4D[0] = mitkSpacing[0];
     spacing4D[1] = mitkSpacing[1];
     spacing4D[2] = mitkSpacing[2];
     spacing4D[3] = 1; // There is no support for a 4D spacing. However, we should have a valid value here
 
     itk::Vector<double, 4u> origin4D;
     origin4D[0] = mitkOrigin[0];
     origin4D[1] = mitkOrigin[1];
     origin4D[2] = mitkOrigin[2];
     origin4D[3] = 0; // There is no support for a 4D origin. However, we should have a valid value here
 
     // Set the necessary information for imageIO
     m_ImageIO->SetNumberOfDimensions(dimension);
     m_ImageIO->SetPixelType(pixelType.GetPixelType());
     m_ImageIO->SetComponentType(pixelType.GetComponentType() < PixelComponentUserType ?
                                   static_cast<itk::ImageIOBase::IOComponentType>(pixelType.GetComponentType()) :
                                   itk::ImageIOBase::UNKNOWNCOMPONENTTYPE);
     m_ImageIO->SetNumberOfComponents( pixelType.GetNumberOfComponents() );
 
     itk::ImageIORegion ioRegion( dimension );
 
     for(unsigned int i = 0; i < dimension; i++)
     {
       m_ImageIO->SetDimensions(i, dimensions[i]);
       m_ImageIO->SetSpacing(i, spacing4D[i]);
       m_ImageIO->SetOrigin(i, origin4D[i]);
 
       mitk::Vector3D mitkDirection;
       mitkDirection.SetVnlVector(geometry->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(i));
       itk::Vector<double, 4u> direction4D;
       direction4D[0] = mitkDirection[0];
       direction4D[1] = mitkDirection[1];
       direction4D[2] = mitkDirection[2];
 
       // MITK only supports a 3x3 direction matrix. Due to templating in itk, however, we must
       // save a 4x4 matrix for 4D images. in this case, add an homogneous component to the matrix.
       if (i == 3)
       {
         direction4D[3] = 1; // homogenous component
       }
       else
       {
         direction4D[3] = 0;
       }
       vnl_vector<double> axisDirection(dimension);
       for(unsigned int j = 0; j < dimension; j++)
       {
         axisDirection[j] = direction4D[j] / spacing4D[i];
       }
       m_ImageIO->SetDirection(i, axisDirection);
 
       ioRegion.SetSize(i, image->GetLargestPossibleRegion().GetSize(i));
       ioRegion.SetIndex(i, image->GetLargestPossibleRegion().GetIndex(i));
     }
 
     //use compression if available
     m_ImageIO->UseCompressionOn();
 
     m_ImageIO->SetIORegion(ioRegion);
     m_ImageIO->SetFileName(path);
 
     // ***** Remove const_cast after bug 17952 is fixed ****
     ImageReadAccessor imageAccess(const_cast<mitk::Image*>(image));
     m_ImageIO->Write(imageAccess.GetData());
   }
   catch (const std::exception& e)
   {
     mitkThrow() << e.what();
   }
 }
 
 AbstractFileIO::ConfidenceLevel ItkImageIO::GetWriterConfidenceLevel() const
 {
   // Check if the image dimension is supported
   const Image* image = dynamic_cast<const Image*>(this->GetInput());
   if (image == NULL)
   {
     // We cannot write a null object, DUH!
     return IFileWriter::Unsupported;
   }
 
   if ( ! m_ImageIO->SupportsDimension(image->GetDimension()))
   {
     // okay, dimension is not supported. We have to look at a special case:
     // 3D-Image with one slice. We can treat that as a 2D image.
     if ((image->GetDimension() == 3) && (image->GetSlicedGeometry()->GetSlices() == 1))
       return IFileWriter::Supported;
     else
       return IFileWriter::Unsupported;
   }
 
   // Check if geometry information will be lost
   if (image->GetDimension() == 2 &&
       !image->GetGeometry()->Is2DConvertable())
   {
     return IFileWriter::PartiallySupported;
   }
   return IFileWriter::Supported;
 }
 
 ItkImageIO* ItkImageIO::IOClone() const
 {
   return new ItkImageIO(*this);
 }
 
 }
diff --git a/Modules/Core/src/mitkCoreActivator.cpp b/Modules/Core/src/mitkCoreActivator.cpp
index 967bcfd675..7fbb056a56 100644
--- a/Modules/Core/src/mitkCoreActivator.cpp
+++ b/Modules/Core/src/mitkCoreActivator.cpp
@@ -1,461 +1,464 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkCoreActivator.h"
 
 // File IO
 #include <mitkIOUtil.h>
 #include <mitkIOMimeTypes.h>
 #include <mitkItkImageIO.h>
 #include <mitkMimeTypeProvider.h>
 #include <mitkPointSetReaderService.h>
 #include <mitkPointSetWriterService.h>
 #include <mitkRawImageFileReader.h>
 #include <mitkSurfaceStlIO.h>
 #include <mitkSurfaceVtkLegacyIO.h>
 #include <mitkSurfaceVtkXmlIO.h>
 #include <mitkImageVtkXmlIO.h>
 #include <mitkImageVtkLegacyIO.h>
 
 #include <mitkFileWriter.h>
 #include "mitkLegacyFileWriterService.h"
 #include "mitkDicomSeriesReaderService.h"
 
 #include <itkNiftiImageIO.h>
 #include <itkGDCMImageIO.h>
 
 // Micro Services
 #include <usGetModuleContext.h>
 #include <usModuleInitialization.h>
 #include <usModuleActivator.h>
 #include <usModuleContext.h>
 #include <usModuleSettings.h>
 #include <usModuleEvent.h>
 #include <usModule.h>
 #include <usModuleResource.h>
 #include <usModuleResourceStream.h>
 #include <usServiceTracker.h>
 
 // ITK "injects" static initialization code for IO factories
 // via the itkImageIOFactoryRegisterManager.h header (which
 // is generated in the application library build directory).
 // To ensure that the code is called *before* the CppMicroServices
 // static initialization code (which triggers the Activator::Start
 // method), we include the ITK header here.
 #include <itkImageIOFactoryRegisterManager.h>
 
 void HandleMicroServicesMessages(us::MsgType type, const char* msg)
 {
   switch (type)
   {
   case us::DebugMsg:
     MITK_DEBUG << msg;
     break;
   case us::InfoMsg:
     MITK_INFO << msg;
     break;
   case us::WarningMsg:
     MITK_WARN << msg;
     break;
   case us::ErrorMsg:
     MITK_ERROR << msg;
     break;
   }
 }
 
 void AddMitkAutoLoadPaths(const std::string& programPath)
 {
   us::ModuleSettings::AddAutoLoadPath(programPath);
 #ifdef __APPLE__
   // Walk up three directories since that is where the .dylib files are located
   // for build trees.
   std::string additionalPath = programPath;
   bool addPath = true;
   for(int i = 0; i < 3; ++i)
   {
     std::size_t index = additionalPath.find_last_of('/');
     if (index != std::string::npos)
     {
       additionalPath = additionalPath.substr(0, index);
     }
     else
     {
       addPath = false;
       break;
     }
   }
   if (addPath)
   {
     us::ModuleSettings::AddAutoLoadPath(additionalPath);
   }
 #endif
 }
 
 class ShaderRepositoryTracker : public us::ServiceTracker<mitk::IShaderRepository>
 {
 
 public:
 
   ShaderRepositoryTracker()
     : Superclass(us::GetModuleContext())
   {
   }
 
   virtual void Close() override
   {
     us::GetModuleContext()->RemoveModuleListener(this, &ShaderRepositoryTracker::HandleModuleEvent);
     Superclass::Close();
   }
 
   virtual void Open() override
   {
     us::GetModuleContext()->AddModuleListener(this, &ShaderRepositoryTracker::HandleModuleEvent);
     Superclass::Open();
   }
 
 private:
 
   typedef us::ServiceTracker<mitk::IShaderRepository> Superclass;
 
   TrackedType AddingService(const ServiceReferenceType &reference) override
   {
     mitk::IShaderRepository* shaderRepo = Superclass::AddingService(reference);
     if (shaderRepo)
     {
       // Add all existing shaders from modules to the new shader repository.
       // If the shader repository is registered in a modules activator, the
       // GetLoadedModules() function call below will also return the module
       // which is currently registering the repository. The HandleModuleEvent
       // method contains code to avoid double registrations due to a fired
       // ModuleEvent::LOADED event after the activators Load() method finished.
       std::vector<us::Module*> modules = us::ModuleRegistry::GetLoadedModules();
       for (std::vector<us::Module*>::const_iterator iter = modules.begin(),
            endIter = modules.end(); iter != endIter; ++iter)
       {
         this->AddModuleShaderToRepository(*iter, shaderRepo);
       }
 
       m_ShaderRepositories.push_back(shaderRepo);
     }
     return shaderRepo;
   }
 
   void RemovedService(const ServiceReferenceType& /*reference*/, TrackedType tracked) override
   {
     m_ShaderRepositories.erase(std::remove(m_ShaderRepositories.begin(), m_ShaderRepositories.end(), tracked),
                                m_ShaderRepositories.end());
   }
 
   void HandleModuleEvent(const us::ModuleEvent moduleEvent)
   {
     if (moduleEvent.GetType() == us::ModuleEvent::LOADED)
     {
       std::vector<mitk::IShaderRepository*> shaderRepos;
       for (std::map<mitk::IShaderRepository*, std::map<long, std::vector<int> > >::const_iterator shaderMapIter = m_ModuleIdToShaderIds.begin(),
            shaderMapEndIter = m_ModuleIdToShaderIds.end(); shaderMapIter != shaderMapEndIter; ++shaderMapIter)
       {
         if (shaderMapIter->second.find(moduleEvent.GetModule()->GetModuleId()) == shaderMapIter->second.end())
         {
           shaderRepos.push_back(shaderMapIter->first);
         }
       }
       AddModuleShadersToRepositories(moduleEvent.GetModule(), shaderRepos);
     }
     else if (moduleEvent.GetType() == us::ModuleEvent::UNLOADED)
     {
       RemoveModuleShadersFromRepositories(moduleEvent.GetModule(), m_ShaderRepositories);
     }
   }
 
   void AddModuleShadersToRepositories(us::Module* module, const std::vector<mitk::IShaderRepository*>& shaderRepos)
   {
     // search and load shader files
     std::vector<us::ModuleResource> shaderResources = module->FindResources("Shaders", "*.xml", true);
     for (std::vector<us::ModuleResource>::iterator i = shaderResources.begin();
          i != shaderResources.end(); ++i)
     {
       if (*i)
       {
         us::ModuleResourceStream rs(*i);
         for (const auto & shaderRepo : shaderRepos)
         {
           int id = (shaderRepo)->LoadShader(rs, i->GetBaseName());
           if (id >= 0)
           {
             m_ModuleIdToShaderIds[shaderRepo][module->GetModuleId()].push_back(id);
           }
         }
         rs.seekg(0, std::ios_base::beg);
       }
     }
   }
 
   void AddModuleShaderToRepository(us::Module* module, mitk::IShaderRepository* shaderRepo)
   {
     std::vector<mitk::IShaderRepository*> shaderRepos;
     shaderRepos.push_back(shaderRepo);
     this->AddModuleShadersToRepositories(module, shaderRepos);
   }
 
   void RemoveModuleShadersFromRepositories(us::Module* module,
                                            const std::vector<mitk::IShaderRepository*>& shaderRepos)
   {
     for (const auto & shaderRepo : shaderRepos)
     {
       std::map<long, std::vector<int> >& moduleIdToShaderIds = m_ModuleIdToShaderIds[shaderRepo];
       std::map<long, std::vector<int> >::iterator shaderIdsIter =
         moduleIdToShaderIds.find(module->GetModuleId());
       if (shaderIdsIter != moduleIdToShaderIds.end())
       {
         for (std::vector<int>::iterator idIter = shaderIdsIter->second.begin();
              idIter != shaderIdsIter->second.end(); ++idIter)
         {
           (shaderRepo)->UnloadShader(*idIter);
         }
         moduleIdToShaderIds.erase(shaderIdsIter);
       }
     }
   }
 
 private:
 
   // Maps to each shader repository a map containing module ids and related
   // shader registration ids
   std::map<mitk::IShaderRepository*, std::map<long, std::vector<int> > > m_ModuleIdToShaderIds;
   std::vector<mitk::IShaderRepository*> m_ShaderRepositories;
 };
 
 class FixedNiftiImageIO : public itk::NiftiImageIO
 {
 public:
 
   /** Standard class typedefs. */
   typedef FixedNiftiImageIO         Self;
   typedef itk::NiftiImageIO         Superclass;
   typedef itk::SmartPointer< Self > Pointer;
 
   /** Method for creation through the object factory. */
   itkNewMacro(Self)
 
   /** Run-time type information (and related methods). */
   itkTypeMacro(FixedNiftiImageIO, Superclass)
 
   virtual bool SupportsDimension(unsigned long dim) override
   {
     return dim > 1 && dim < 5;
   }
 
 };
 
 void MitkCoreActivator::Load(us::ModuleContext* context)
 {
   // Handle messages from CppMicroServices
   us::installMsgHandler(HandleMicroServicesMessages);
 
   this->m_Context = context;
 
   // Add the current application directory to the auto-load paths.
   // This is useful for third-party executables.
   std::string programPath = mitk::IOUtil::GetProgramPath();
   if (programPath.empty())
   {
     MITK_WARN << "Could not get the program path.";
   }
   else
   {
     AddMitkAutoLoadPaths(programPath);
   }
 
   m_ShaderRepositoryTracker.reset(new ShaderRepositoryTracker);
 
   //m_RenderingManager = mitk::RenderingManager::New();
   //context->RegisterService<mitk::RenderingManager>(renderingManager.GetPointer());
   m_PlanePositionManager.reset(new mitk::PlanePositionManagerService);
   context->RegisterService<mitk::PlanePositionManagerService>(m_PlanePositionManager.get());
 
   m_PropertyAliases.reset(new mitk::PropertyAliases);
   context->RegisterService<mitk::IPropertyAliases>(m_PropertyAliases.get());
 
   m_PropertyDescriptions.reset(new mitk::PropertyDescriptions);
   context->RegisterService<mitk::IPropertyDescriptions>(m_PropertyDescriptions.get());
 
   m_PropertyExtensions.reset(new mitk::PropertyExtensions);
   context->RegisterService<mitk::IPropertyExtensions>(m_PropertyExtensions.get());
 
   m_PropertyFilters.reset(new mitk::PropertyFilters);
   context->RegisterService<mitk::IPropertyFilters>(m_PropertyFilters.get());
 
+  m_PropertyPersistence.reset(new mitk::PropertyPersistence);
+  context->RegisterService<mitk::IPropertyPersistence>(m_PropertyPersistence.get());
+
   m_MimeTypeProvider.reset(new mitk::MimeTypeProvider);
   m_MimeTypeProvider->Start();
   m_MimeTypeProviderReg = context->RegisterService<mitk::IMimeTypeProvider>(m_MimeTypeProvider.get());
 
   this->RegisterDefaultMimeTypes();
   this->RegisterItkReaderWriter();
   this->RegisterVtkReaderWriter();
 
   // Add custom Reader / Writer Services
   m_FileReaders.push_back(new mitk::PointSetReaderService());
   m_FileWriters.push_back(new mitk::PointSetWriterService());
   m_FileReaders.push_back(new mitk::DicomSeriesReaderService());
   m_FileReaders.push_back(new mitk::RawImageFileReaderService());
 
   m_ShaderRepositoryTracker->Open();
 
   /*
     There IS an option to exchange ALL vtkTexture instances against vtkNeverTranslucentTextureFactory.
     This code is left here as a reminder, just in case we might need to do that some time.
 
     vtkNeverTranslucentTextureFactory* textureFactory = vtkNeverTranslucentTextureFactory::New();
     vtkObjectFactory::RegisterFactory( textureFactory );
     textureFactory->Delete();
     */
 
   this->RegisterLegacyWriter();
 }
 
 void MitkCoreActivator::Unload(us::ModuleContext* )
 {
   for(auto & elem : m_FileReaders)
   {
     delete elem;
   }
 
   for(auto & elem : m_FileWriters)
   {
     delete elem;
   }
 
   for(auto & elem : m_FileIOs)
   {
     delete elem;
   }
 
   for(auto & elem : m_LegacyWriters)
   {
     delete elem;
   }
 
   // The mitk::ModuleContext* argument of the Unload() method
   // will always be 0 for the Mitk library. It makes no sense
   // to use it at this stage anyway, since all libraries which
   // know about the module system have already been unloaded.
 
   // we need to close the internal service tracker of the
   // MimeTypeProvider class here. Otherwise it
   // would hold on to the ModuleContext longer than it is
   // actually valid.
   m_MimeTypeProviderReg.Unregister();
   m_MimeTypeProvider->Stop();
 
   for (std::vector<mitk::CustomMimeType*>::const_iterator mimeTypeIter = m_DefaultMimeTypes.begin(),
        iterEnd = m_DefaultMimeTypes.end(); mimeTypeIter != iterEnd; ++mimeTypeIter)
   {
     delete *mimeTypeIter;
   }
 
   m_ShaderRepositoryTracker->Close();
 }
 
 void MitkCoreActivator::RegisterDefaultMimeTypes()
 {
   // Register some default mime-types
 
   std::vector<mitk::CustomMimeType*> mimeTypes = mitk::IOMimeTypes::Get();
   for (std::vector<mitk::CustomMimeType*>::const_iterator mimeTypeIter = mimeTypes.begin(),
        iterEnd = mimeTypes.end(); mimeTypeIter != iterEnd; ++mimeTypeIter)
   {
     m_DefaultMimeTypes.push_back(*mimeTypeIter);
     m_Context->RegisterService(m_DefaultMimeTypes.back());
   }
 }
 
 void MitkCoreActivator::RegisterItkReaderWriter()
 {
   std::list<itk::LightObject::Pointer> allobjects =
     itk::ObjectFactoryBase::CreateAllInstance("itkImageIOBase");
 
   for (auto & allobject : allobjects)
   {
     itk::ImageIOBase* io = dynamic_cast<itk::ImageIOBase*>(allobject.GetPointer());
 
     // NiftiImageIO does not provide a correct "SupportsDimension()" methods
     // and the supported read/write extensions are not ordered correctly
     if (dynamic_cast<itk::NiftiImageIO*>(io)) continue;
 
     // Use a custom mime-type for GDCMImageIO below
     if (dynamic_cast<itk::GDCMImageIO*>(allobject.GetPointer()))
     {
       // MITK provides its own DICOM reader (which internally uses GDCMImageIO).
       continue;
     }
 
     if (io)
     {
       m_FileIOs.push_back(new mitk::ItkImageIO(io));
     }
     else
     {
       MITK_WARN << "Error ImageIO factory did not return an ImageIOBase: "
                 << ( allobject )->GetNameOfClass();
     }
   }
 
   FixedNiftiImageIO::Pointer itkNiftiIO = FixedNiftiImageIO::New();
   mitk::ItkImageIO* niftiIO = new mitk::ItkImageIO(mitk::IOMimeTypes::NIFTI_MIMETYPE(),
                                                    itkNiftiIO.GetPointer(), 0);
   m_FileIOs.push_back(niftiIO);
 }
 
 void MitkCoreActivator::RegisterVtkReaderWriter()
 {
   m_FileIOs.push_back(new mitk::SurfaceVtkXmlIO());
   m_FileIOs.push_back(new mitk::SurfaceStlIO());
   m_FileIOs.push_back(new mitk::SurfaceVtkLegacyIO());
 
   m_FileIOs.push_back(new mitk::ImageVtkXmlIO());
   m_FileIOs.push_back(new mitk::ImageVtkLegacyIO());
 }
 
 void MitkCoreActivator::RegisterLegacyWriter()
 {
   std::list<itk::LightObject::Pointer> allobjects = itk::ObjectFactoryBase::CreateAllInstance("IOWriter");
 
   for( std::list<itk::LightObject::Pointer>::iterator i = allobjects.begin();
        i != allobjects.end(); ++i)
   {
     mitk::FileWriter::Pointer io = dynamic_cast<mitk::FileWriter*>(i->GetPointer());
     if(io)
     {
       std::string description = std::string("Legacy ") + io->GetNameOfClass() + " Writer";
       mitk::IFileWriter* writer = new mitk::LegacyFileWriterService(io, description);
       m_LegacyWriters.push_back(writer);
     }
     else
     {
       MITK_ERROR << "Error IOWriter override is not of type mitk::FileWriter: "
                  << (*i)->GetNameOfClass()
                  << std::endl;
     }
   }
 }
 
 US_EXPORT_MODULE_ACTIVATOR(MitkCoreActivator)
 
 // Call CppMicroservices initialization code at the end of the file.
 // This especially ensures that VTK object factories have already
 // been registered (VTK initialization code is injected by implicitly
 // include VTK header files at the top of this file).
 US_INITIALIZE_MODULE
diff --git a/Modules/Core/src/mitkCoreActivator.h b/Modules/Core/src/mitkCoreActivator.h
index feafa21c7f..d092790b49 100644
--- a/Modules/Core/src/mitkCoreActivator.h
+++ b/Modules/Core/src/mitkCoreActivator.h
@@ -1,87 +1,89 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef MITKCOREACTIVATOR_H_
 #define MITKCOREACTIVATOR_H_
 
 // File IO
 #include <mitkIFileReader.h>
 #include <mitkIFileWriter.h>
 #include <mitkAbstractFileIO.h>
 
 #include <mitkIShaderRepository.h>
 
 #include <mitkPlanePositionManager.h>
 #include <mitkPropertyAliases.h>
 #include <mitkPropertyDescriptions.h>
 #include <mitkPropertyExtensions.h>
 #include <mitkPropertyFilters.h>
+#include <mitkPropertyPersistence.h>
 #include <mitkMimeTypeProvider.h>
 
 // Micro Services
 #include <usModuleActivator.h>
 #include <usModuleEvent.h>
 #include <usServiceRegistration.h>
 #include <usServiceTracker.h>
 
 #include <memory>
 
 
 /*
  * This is the module activator for the "Mitk" module. It registers core services
  * like ...
  */
 class MitkCoreActivator : public us::ModuleActivator
 {
 public:
 
   void Load(us::ModuleContext* context) override;
   void Unload(us::ModuleContext* ) override;
 
 private:
 
   void HandleModuleEvent(const us::ModuleEvent moduleEvent);
 
   void RegisterDefaultMimeTypes();
   void RegisterItkReaderWriter();
   void RegisterVtkReaderWriter();
 
   void RegisterLegacyWriter();
 
   std::auto_ptr<us::ServiceTracker<mitk::IShaderRepository> > m_ShaderRepositoryTracker;
 
   //mitk::RenderingManager::Pointer m_RenderingManager;
   std::auto_ptr<mitk::PlanePositionManagerService> m_PlanePositionManager;
   std::auto_ptr<mitk::PropertyAliases> m_PropertyAliases;
   std::auto_ptr<mitk::PropertyDescriptions> m_PropertyDescriptions;
   std::auto_ptr<mitk::PropertyExtensions> m_PropertyExtensions;
   std::auto_ptr<mitk::PropertyFilters> m_PropertyFilters;
+  std::auto_ptr<mitk::PropertyPersistence> m_PropertyPersistence;
   std::auto_ptr<mitk::MimeTypeProvider> m_MimeTypeProvider;
 
   // File IO
   std::vector<mitk::IFileReader*> m_FileReaders;
   std::vector<mitk::IFileWriter*> m_FileWriters;
   std::vector<mitk::AbstractFileIO*> m_FileIOs;
   std::vector<mitk::IFileWriter*> m_LegacyWriters;
 
   std::vector<mitk::CustomMimeType*> m_DefaultMimeTypes;
 
   us::ServiceRegistration<mitk::IMimeTypeProvider> m_MimeTypeProviderReg;
 
   us::ModuleContext* m_Context;
 };
 
 #endif // MITKCOREACTIVATOR_H_
diff --git a/Modules/Core/src/mitkCoreServices.cpp b/Modules/Core/src/mitkCoreServices.cpp
index 06c9d2c44c..44ee1d7bed 100644
--- a/Modules/Core/src/mitkCoreServices.cpp
+++ b/Modules/Core/src/mitkCoreServices.cpp
@@ -1,127 +1,133 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkCoreServices.h"
 
 #include <mitkIMimeTypeProvider.h>
 #include <mitkIPropertyAliases.h>
 #include <mitkIPropertyDescriptions.h>
 #include <mitkIPropertyExtensions.h>
 #include <mitkIPropertyFilters.h>
+#include <mitkIPropertyPersistence.h>
 #include <mitkIShaderRepository.h>
 
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 #include <usServiceReference.h>
 #include <usServiceTracker.h>
 
 #include <itkSimpleFastMutexLock.h>
 #include <itkMutexLockHolder.h>
 
 namespace mitk {
 
 itk::SimpleFastMutexLock& s_ContextToServicesMapMutex()
 {
   static itk::SimpleFastMutexLock mutex;
   return mutex;
 }
 
 std::map<us::ModuleContext*, std::map<void*,us::ServiceReferenceU> >& s_ContextToServicesMap()
 {
   static std::map<us::ModuleContext*, std::map<void*,us::ServiceReferenceU> > serviceMap;
   return serviceMap;
 }
 
 template<class S>
 static S* GetCoreService(us::ModuleContext* context)
 {
   if (context == NULL) context = us::GetModuleContext();
 
   S* coreService = NULL;
   us::ServiceReference<S> serviceRef = context->GetServiceReference<S>();
   if (serviceRef)
   {
     coreService = context->GetService(serviceRef);
   }
 
   assert(coreService && "Asserting non-NULL MITK core service");
   {
     itk::MutexLockHolder<itk::SimpleFastMutexLock> l(s_ContextToServicesMapMutex());
     s_ContextToServicesMap()[context].insert(std::make_pair(coreService,serviceRef));
   }
 
   return coreService;
 }
 
 IShaderRepository* CoreServices::GetShaderRepository()
 {
   static us::ServiceTracker<IShaderRepository> tracker(us::GetModuleContext());
   tracker.Open();
   return tracker.GetService();
 }
 
 IPropertyAliases* CoreServices::GetPropertyAliases(us::ModuleContext* context)
 {
   return GetCoreService<IPropertyAliases>(context);
 }
 
 IPropertyDescriptions* CoreServices::GetPropertyDescriptions(us::ModuleContext* context)
 {
   return GetCoreService<IPropertyDescriptions>(context);
 }
 
 IPropertyExtensions* CoreServices::GetPropertyExtensions(us::ModuleContext* context)
 {
   return GetCoreService<IPropertyExtensions>(context);
 }
 
 IPropertyFilters* CoreServices::GetPropertyFilters(us::ModuleContext* context)
 {
   return GetCoreService<IPropertyFilters>(context);
 }
 
+IPropertyPersistence* CoreServices::GetPropertyPersistence(us::ModuleContext* context)
+{
+  return GetCoreService<IPropertyPersistence>(context);
+}
+
 IMimeTypeProvider* CoreServices::GetMimeTypeProvider(us::ModuleContext* context)
 {
   return GetCoreService<IMimeTypeProvider>(context);
 }
 
 bool CoreServices::Unget(us::ModuleContext* context, const std::string& /*interfaceId*/, void* service)
 {
   bool success = false;
 
   itk::MutexLockHolder<itk::SimpleFastMutexLock> l(s_ContextToServicesMapMutex());
   std::map<us::ModuleContext*, std::map<void*,us::ServiceReferenceU> >::iterator iter = s_ContextToServicesMap().find(context);
   if (iter != s_ContextToServicesMap().end())
   {
     std::map<void*,us::ServiceReferenceU>::iterator iter2 = iter->second.find(service);
     if (iter2 != iter->second.end())
     {
       us::ServiceReferenceU serviceRef = iter2->second;
       if (serviceRef)
       {
         success = context->UngetService(serviceRef);
         if (success)
         {
           iter->second.erase(iter2);
         }
       }
     }
   }
 
   return success;
 }
 
 }
diff --git a/Plugins/org.mitk.gui.qt.ext/resources/icons/awesome/scalable/tag.svg b/Plugins/org.mitk.gui.qt.ext/resources/icons/awesome/scalable/tag.svg
new file mode 100644
index 0000000000..af15475e17
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.ext/resources/icons/awesome/scalable/tag.svg
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 16.0.4, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" id="Capa_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 width="216px" height="146px" viewBox="0 0 216 146" enable-background="new 0 0 216 146" xml:space="preserve">
+<path d="M166.703,76.869l-58.254-58.172c-2.064-2.065-4.834-3.816-8.31-5.255c-3.477-1.439-6.654-2.159-9.533-2.159H56.713
+	c-2.825,0-5.269,1.033-7.333,3.096c-2.064,2.064-3.096,4.508-3.096,7.333v33.893c0,2.879,0.719,6.055,2.159,9.532
+	s3.191,6.219,5.255,8.229l58.253,58.335c2.01,2.01,4.453,3.015,7.333,3.015c2.823,0,5.296-1.005,7.414-3.015l40.004-40.085
+	c2.01-2.011,3.014-4.453,3.014-7.332C169.716,81.46,168.712,78.988,166.703,76.869z M79.729,44.728
+	c-2.038,2.037-4.495,3.056-7.374,3.056c-2.878,0-5.336-1.019-7.373-3.056s-3.055-4.494-3.055-7.373s1.018-5.337,3.055-7.373
+	c2.037-2.037,4.495-3.056,7.373-3.056c2.879,0,5.337,1.019,7.374,3.056c2.036,2.036,3.055,4.494,3.055,7.373
+	S81.766,42.691,79.729,44.728z"/>
+</svg>
diff --git a/Plugins/org.mitk.gui.qt.ext/resources/icons/awesome/scalable/tags.svg b/Plugins/org.mitk.gui.qt.ext/resources/icons/awesome/scalable/tags.svg
new file mode 100644
index 0000000000..48242a0040
--- /dev/null
+++ b/Plugins/org.mitk.gui.qt.ext/resources/icons/awesome/scalable/tags.svg
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 16.0.4, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg version="1.1" id="Capa_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 width="216px" height="146px" viewBox="0 0 216 146" enable-background="new 0 0 216 146" xml:space="preserve">
+<g>
+	<path d="M154.073,84.284c0-2.824-1.005-5.296-3.015-7.415L92.805,18.697c-2.064-2.065-4.834-3.816-8.31-5.255
+		c-3.476-1.439-6.654-2.159-9.533-2.159H41.069c-2.824,0-5.269,1.033-7.332,3.096c-2.065,2.064-3.097,4.508-3.097,7.333v33.893
+		c0,2.879,0.719,6.055,2.159,9.532s3.192,6.219,5.255,8.229l58.254,58.335c2.01,2.01,4.454,3.015,7.332,3.015
+		c2.825,0,5.297-1.005,7.415-3.015l40.004-40.085C153.068,89.605,154.073,87.163,154.073,84.284z M64.086,44.728
+		c-2.037,2.037-4.495,3.056-7.374,3.056c-2.878,0-5.336-1.019-7.373-3.056s-3.055-4.494-3.055-7.373s1.018-5.337,3.055-7.373
+		c2.037-2.037,4.495-3.056,7.373-3.056c2.879,0,5.337,1.019,7.374,3.056c2.036,2.036,3.055,4.494,3.055,7.373
+		S66.122,42.691,64.086,44.728z"/>
+	<path d="M182.343,76.87L124.09,18.698c-2.064-2.065-4.834-3.816-8.311-5.255c-3.475-1.439-6.653-2.159-9.532-2.159h-18.25
+		c2.879,0,6.056,0.72,9.532,2.159c3.477,1.44,6.247,3.191,8.311,5.255l58.253,58.172c2.011,2.118,3.017,4.59,3.017,7.414
+		c0,2.879-1.006,5.321-3.017,7.332l-38.292,38.293c1.631,1.684,3.069,2.905,4.318,3.666s2.852,1.141,4.807,1.141
+		c2.825,0,5.297-1.005,7.414-3.015l40.003-40.085c2.011-2.011,3.017-4.453,3.017-7.332C185.359,81.46,184.354,78.988,182.343,76.87z
+		"/>
+</g>
+</svg>
diff --git a/Plugins/org.mitk.gui.qt.ext/resources/org_mitk_icons.qrc b/Plugins/org.mitk.gui.qt.ext/resources/org_mitk_icons.qrc
index 08f6548161..4d67ab9b0f 100644
--- a/Plugins/org.mitk.gui.qt.ext/resources/org_mitk_icons.qrc
+++ b/Plugins/org.mitk.gui.qt.ext/resources/org_mitk_icons.qrc
@@ -1,67 +1,68 @@
 <!DOCTYPE RCC><RCC version="1.0">
  <qresource prefix="/org_mitk_icons">
      <file>icons/awesome/index.theme</file>
      <file>icons/awesome/scalable/actions/document-open.svg</file>
      <file>icons/awesome/scalable/actions/document-print.svg</file>
      <file>icons/awesome/scalable/actions/document-save.svg</file>
      <file>icons/awesome/scalable/actions/edit-delete.svg</file>
      <file>icons/awesome/scalable/actions/edit-redo.svg</file>
      <file>icons/awesome/scalable/actions/edit-undo.svg</file>
      <file>icons/awesome/scalable/actions/go-down.svg</file>
      <file>icons/awesome/scalable/actions/go-home.svg</file>
      <file>icons/awesome/scalable/actions/go-next.svg</file>
      <file>icons/awesome/scalable/actions/go-previous.svg</file>
      <file>icons/awesome/scalable/actions/go-up.svg</file>
      <file>icons/awesome/scalable/actions/system-log-out.svg</file>
      <file>icons/awesome/scalable/actions/view-list-details.svg</file>
      <file>icons/awesome/scalable/actions/view-list-icons.svg</file>
      <file>icons/awesome/scalable/actions/view-refresh.svg</file>
      <file>icons/awesome/scalable/places/folder.svg</file>
      <file>icons/awesome/scalable/status/dialog-error.svg</file>
      <file>icons/awesome/scalable/status/dialog-information.svg</file>
      <file>icons/awesome/scalable/status/dialog-question.svg</file>
      <file>icons/awesome/scalable/status/dialog-warning.svg</file>
+     <file>icons/awesome/scalable/tag.svg</file>
+     <file>icons/awesome/scalable/tags.svg</file>
      <file>icons/tango/index.theme</file>
      <file>icons/tango/scalable/actions/document-open.svg</file>
      <file>icons/tango/scalable/actions/document-print.svg</file>
      <file>icons/tango/scalable/actions/document-save.svg</file>
      <file>icons/tango/scalable/actions/edit-delete.svg</file>
      <file>icons/tango/scalable/actions/edit-redo.svg</file>
      <file>icons/tango/scalable/actions/edit-undo.svg</file>
      <file>icons/tango/scalable/actions/go-bottom.svg</file>
      <file>icons/tango/scalable/actions/go-down.svg</file>
      <file>icons/tango/scalable/actions/go-first.svg</file>
      <file>icons/tango/scalable/actions/go-home.svg</file>
      <file>icons/tango/scalable/actions/go-last.svg</file>
      <file>icons/tango/scalable/actions/go-next.svg</file>
      <file>icons/tango/scalable/actions/go-previous.svg</file>
      <file>icons/tango/scalable/actions/go-top.svg</file>
      <file>icons/tango/scalable/actions/go-up.svg</file>
      <file>icons/tango/scalable/actions/system-log-out.svg</file>
      <file>icons/tango/scalable/actions/view-list-details.svg</file>
      <file>icons/tango/scalable/actions/view-list-icons.svg</file>
      <file>icons/tango/scalable/actions/view-refresh.svg</file>
      <file>icons/tango/scalable/actions/list-add.svg</file>
      <file>icons/tango/scalable/actions/list-remove.svg</file>
      <file>icons/tango/scalable/actions/media-playback-pause.svg</file>
      <file>icons/tango/scalable/actions/media-playback-start.svg</file>
      <file>icons/tango/scalable/actions/media-playback-stop.svg</file>
      <file>icons/tango/scalable/actions/media-record.svg</file>
      <file>icons/tango/scalable/actions/media-seek-backward.svg</file>
      <file>icons/tango/scalable/actions/media-seek-forward.svg</file>
      <file>icons/tango/scalable/actions/media-skip-backward.svg</file>
      <file>icons/tango/scalable/actions/media-skip-forward.svg</file>
-     <file>icons/tango/scalable/actions/system-log-out.svg</file>
      <file>icons/tango/scalable/categories/applications-multimedia.svg</file>
      <file>icons/tango/scalable/devices/camera-photo.svg</file>
      <file>icons/tango/scalable/devices/camera-video.svg</file>
      <file>icons/tango/scalable/mimetypes/image-x-generic.svg</file>
      <file>icons/tango/scalable/mimetypes/video-x-generic.svg</file>
      <file>icons/tango/scalable/places/folder.svg</file>
      <file>icons/tango/scalable/places/folder-remote.svg</file>
      <file>icons/tango/scalable/status/dialog-error.svg</file>
      <file>icons/tango/scalable/status/dialog-information.svg</file>
      <file>icons/tango/scalable/status/dialog-question.svg</file>
      <file>icons/tango/scalable/status/dialog-warning.svg</file>
  </qresource>
  </RCC>
diff --git a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkAddNewPropertyDialog.cpp b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkAddNewPropertyDialog.cpp
index 857bf49d3e..7b183a0362 100644
--- a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkAddNewPropertyDialog.cpp
+++ b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkAddNewPropertyDialog.cpp
@@ -1,191 +1,205 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkAddNewPropertyDialog.h"
+#include "mitkGetPropertyService.h"
+#include <mitkIPropertyPersistence.h>
 #include <mitkProperties.h>
 #include <QMessageBox>
 #include <cassert>
 
 QmitkAddNewPropertyDialog::QmitkAddNewPropertyDialog(mitk::BaseData::Pointer baseData, QWidget* parent)
   : QDialog(parent),
     m_BaseData(baseData)
 {
   this->Initialize();
 }
 
 QmitkAddNewPropertyDialog::QmitkAddNewPropertyDialog(mitk::DataNode::Pointer dataNode, mitk::BaseRenderer::Pointer renderer, QWidget* parent)
   : QDialog(parent),
     m_DataNode(dataNode),
     m_Renderer(renderer)
 {
   this->Initialize();
 }
 
 QmitkAddNewPropertyDialog::~QmitkAddNewPropertyDialog()
 {
 }
 
 void QmitkAddNewPropertyDialog::Initialize()
 {
   m_Controls.setupUi(this);
 
   QStringList types;
   types << "bool" << "double" << "float" << "int" << "string";
 
   m_Controls.typeComboBox->addItems(types);
 
+  m_Controls.persistentLabel->setVisible(m_BaseData.IsNotNull());
+  m_Controls.persistentCheckBox->setVisible(m_BaseData.IsNotNull());
+
   connect(m_Controls.typeComboBox, SIGNAL(currentIndexChanged(const QString&)), this, SLOT(ShowAdequateValueWidget(const QString&)));
   connect(m_Controls.addButton, SIGNAL(clicked()), this, SLOT(AddNewProperty()));
   connect(m_Controls.cancelButton, SIGNAL(clicked()), this, SLOT(reject()));
 
   this->ShowAdequateValueWidget(types[0]);
 }
 
 void QmitkAddNewPropertyDialog::AddNewProperty()
 {
   if (m_Controls.nameLineEdit->text().isEmpty())
   {
     QMessageBox::critical(this, "No name specified", "Enter a property name.");
     return;
   }
 
   if (!this->ValidateValue())
   {
     QMessageBox::critical(this, "Invalid value", "Enter a valid " + m_Controls.typeComboBox->currentText() + " value.");
     return;
   }
 
   if (m_BaseData.IsNotNull())
   {
-    m_BaseData->SetProperty(m_Controls.nameLineEdit->text().toLatin1(), this->CreateProperty());
+    mitk::BaseProperty::Pointer property = this->CreateProperty();
+    m_BaseData->SetProperty(m_Controls.nameLineEdit->text().toLatin1(), property);
+
+    if (m_Controls.persistentCheckBox->isChecked())
+    {
+      mitk::IPropertyPersistence* propertyPersistence = mitk::GetPropertyService<mitk::IPropertyPersistence>();
+
+      if (propertyPersistence != nullptr)
+        propertyPersistence->AddInfo(m_Controls.nameLineEdit->text().toStdString(), mitk::PropertyPersistenceInfo::New());
+    }
   }
   else
   {
     m_DataNode->SetProperty(m_Controls.nameLineEdit->text().toLatin1(), this->CreateProperty(), m_Renderer);
   }
 
   this->accept();
 }
 
 mitk::BaseProperty::Pointer QmitkAddNewPropertyDialog::CreateProperty() const
 {
   QString type = m_Controls.typeComboBox->currentText();
 
   if (type == "bool")
   {
     return mitk::BoolProperty::New(m_Controls.valueCheckBox->isChecked()).GetPointer();
   }
   else if (type == "double")
   {
     return mitk::DoubleProperty::New(m_Controls.valueLineEdit->text().toDouble()).GetPointer();
   }
   else if (type == "float")
   {
     return mitk::FloatProperty::New(m_Controls.valueLineEdit->text().toFloat()).GetPointer();
   }
   else if (type == "int")
   {
     return mitk::IntProperty::New(m_Controls.valueLineEdit->text().toInt()).GetPointer();
   }
   else if (type == "string")
   {
     return mitk::StringProperty::New(m_Controls.valueLineEdit->text().toStdString()).GetPointer();
   }
   else
   {
     assert(false && "Property creation for selected type not implemented!");
   }
 
   return NULL;
 }
 
 bool QmitkAddNewPropertyDialog::ValidateValue()
 {
   QString type = m_Controls.typeComboBox->currentText();
 
   if (type == "bool")
   {
     return true;
   }
   else if (type == "double")
   {
     bool ok = false;
     m_Controls.valueLineEdit->text().toDouble(&ok);
 
     return ok;
   }
   else if (type == "float")
   {
     bool ok = false;
     m_Controls.valueLineEdit->text().toFloat(&ok);
 
     return ok;
   }
   else if (type == "int")
   {
     bool ok = false;
     m_Controls.valueLineEdit->text().toInt(&ok);
 
     return ok;
   }
   else if (type == "string")
   {
     return true;
   }
   else
   {
     assert(false && "Value validation for selected type not implemented!");
   }
 
   return false;
 }
 
 void QmitkAddNewPropertyDialog::ShowAdequateValueWidget(const QString& type)
 {
   m_Controls.valueLineEdit->clear();
   m_Controls.valueLineEdit->hide();
 
   m_Controls.valueCheckBox->setChecked(false);
   m_Controls.valueCheckBox->hide();
 
   if (type == "bool")
   {
     m_Controls.valueCheckBox->show();
   }
   else if (type == "double")
   {
     m_Controls.valueLineEdit->setText("0");
     m_Controls.valueLineEdit->show();
   }
   else if (type == "float")
   {
     m_Controls.valueLineEdit->setText("0");
     m_Controls.valueLineEdit->show();
   }
   else if (type == "int")
   {
     m_Controls.valueLineEdit->setText("0");
     m_Controls.valueLineEdit->show();
   }
   else if (type == "string")
   {
     m_Controls.valueLineEdit->show();
   }
   else
   {
     assert(false && "No adequate value widget specified for selected type!");
   }
 }
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkAddNewPropertyDialog.ui b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkAddNewPropertyDialog.ui
index cdc9275679..7d43ecd41e 100644
--- a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkAddNewPropertyDialog.ui
+++ b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkAddNewPropertyDialog.ui
@@ -1,127 +1,153 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkAddNewPropertyDialog</class>
  <widget class="QDialog" name="QmitkAddNewPropertyDialog">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>253</width>
-    <height>150</height>
+    <width>319</width>
+    <height>235</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Add new property</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_2">
    <item>
     <layout class="QFormLayout" name="formLayout">
      <item row="0" column="0">
       <widget class="QLabel" name="nameLabel">
        <property name="text">
         <string>Name</string>
        </property>
+       <property name="buddy">
+        <cstring>nameLineEdit</cstring>
+       </property>
       </widget>
      </item>
      <item row="0" column="1">
       <widget class="QLineEdit" name="nameLineEdit"/>
      </item>
      <item row="1" column="0">
       <widget class="QLabel" name="typeLabel">
        <property name="text">
         <string>Type</string>
        </property>
+       <property name="buddy">
+        <cstring>typeComboBox</cstring>
+       </property>
       </widget>
      </item>
      <item row="1" column="1">
       <widget class="QComboBox" name="typeComboBox"/>
      </item>
      <item row="2" column="0">
       <widget class="QLabel" name="valueLabel">
        <property name="text">
         <string>Value</string>
        </property>
+       <property name="buddy">
+        <cstring>valueLineEdit</cstring>
+       </property>
       </widget>
      </item>
      <item row="2" column="1">
       <layout class="QVBoxLayout" name="verticalLayout">
        <item>
         <widget class="QLineEdit" name="valueLineEdit"/>
        </item>
        <item>
         <widget class="QCheckBox" name="valueCheckBox">
          <property name="text">
           <string/>
          </property>
         </widget>
        </item>
       </layout>
      </item>
+     <item row="3" column="0">
+      <widget class="QLabel" name="persistentLabel">
+       <property name="text">
+        <string>Persistent</string>
+       </property>
+       <property name="buddy">
+        <cstring>persistentCheckBox</cstring>
+       </property>
+      </widget>
+     </item>
+     <item row="3" column="1">
+      <widget class="QCheckBox" name="persistentCheckBox">
+       <property name="text">
+        <string/>
+       </property>
+      </widget>
+     </item>
     </layout>
    </item>
    <item>
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>2</height>
       </size>
      </property>
     </spacer>
    </item>
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout">
      <item>
       <spacer name="horizontalSpacer">
        <property name="orientation">
         <enum>Qt::Horizontal</enum>
        </property>
        <property name="sizeHint" stdset="0">
         <size>
          <width>40</width>
          <height>20</height>
         </size>
        </property>
       </spacer>
      </item>
      <item>
       <widget class="QPushButton" name="addButton">
        <property name="text">
         <string>&amp;Add</string>
        </property>
        <property name="autoDefault">
         <bool>false</bool>
        </property>
        <property name="default">
         <bool>true</bool>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QPushButton" name="cancelButton">
        <property name="text">
         <string>&amp;Cancel</string>
        </property>
        <property name="autoDefault">
         <bool>false</bool>
        </property>
       </widget>
      </item>
     </layout>
    </item>
   </layout>
  </widget>
  <tabstops>
   <tabstop>nameLineEdit</tabstop>
   <tabstop>typeComboBox</tabstop>
   <tabstop>valueLineEdit</tabstop>
   <tabstop>valueCheckBox</tabstop>
   <tabstop>addButton</tabstop>
   <tabstop>cancelButton</tabstop>
  </tabstops>
  <resources/>
  <connections/>
 </ui>
diff --git a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertiesPreferencePage.cpp b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertiesPreferencePage.cpp
index 7835cab9d4..dcdb9982a5 100644
--- a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertiesPreferencePage.cpp
+++ b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertiesPreferencePage.cpp
@@ -1,83 +1,87 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkPropertiesPreferencePage.h"
 #include <berryIPreferencesService.h>
 #include <berryPlatform.h>
 
 const QString QmitkPropertiesPreferencePage::FILTER_PROPERTIES = "filter properties";
 const QString QmitkPropertiesPreferencePage::SHOW_ALIASES = "show aliases";
 const QString QmitkPropertiesPreferencePage::SHOW_DESCRIPTIONS = "show descriptions";
 const QString QmitkPropertiesPreferencePage::SHOW_ALIASES_IN_DESCRIPTION = "show aliases in description";
+const QString QmitkPropertiesPreferencePage::SHOW_PERSISTENCE_IN_DESCRIPTION = "show persistence in description";
 const QString QmitkPropertiesPreferencePage::DEVELOPER_MODE = "enable developer mode";
 
 QmitkPropertiesPreferencePage::QmitkPropertiesPreferencePage()
   : m_Control(nullptr),
     m_Preferences(berry::Platform::GetPreferencesService()->GetSystemPreferences()->Node("/org.mitk.views.properties"))
 {
 }
 
 QmitkPropertiesPreferencePage::~QmitkPropertiesPreferencePage()
 {
 }
 
 void QmitkPropertiesPreferencePage::CreateQtControl(QWidget* parent)
 {
   m_Control = new QWidget(parent);
   m_Controls.setupUi(m_Control);
 
   connect(m_Controls.showDescriptionsCheckBox, SIGNAL(stateChanged(int)), this, SLOT(OnShowDescriptionsStateChanged(int)));
 
   this->Update();
 }
 
 QWidget* QmitkPropertiesPreferencePage::GetQtControl() const
 {
   return m_Control;
 }
 
 void QmitkPropertiesPreferencePage::Init(berry::IWorkbench::Pointer)
 {
 }
 
 void QmitkPropertiesPreferencePage::OnShowDescriptionsStateChanged(int state)
 {
   m_Controls.showAliasesInDescriptionCheckBox->setEnabled(state != Qt::Unchecked);
+  m_Controls.showPersistenceInDescriptionCheckBox->setEnabled(state != Qt::Unchecked);
 }
 
 bool QmitkPropertiesPreferencePage::PerformOk()
 {
   m_Preferences->PutBool(FILTER_PROPERTIES, m_Controls.filterPropertiesCheckBox->isChecked());
   m_Preferences->PutBool(SHOW_ALIASES, m_Controls.showAliasesCheckBox->isChecked());
   m_Preferences->PutBool(SHOW_DESCRIPTIONS, m_Controls.showDescriptionsCheckBox->isChecked());
   m_Preferences->PutBool(SHOW_ALIASES_IN_DESCRIPTION, m_Controls.showAliasesInDescriptionCheckBox->isChecked());
+  m_Preferences->PutBool(SHOW_PERSISTENCE_IN_DESCRIPTION, m_Controls.showPersistenceInDescriptionCheckBox->isChecked());
   m_Preferences->PutBool(DEVELOPER_MODE, m_Controls.enableDeveloperModeCheckBox->isChecked());
 
   return true;
 }
 
 void QmitkPropertiesPreferencePage::PerformCancel()
 {
 }
 
 void QmitkPropertiesPreferencePage::Update()
 {
   m_Controls.filterPropertiesCheckBox->setChecked(m_Preferences->GetBool(FILTER_PROPERTIES, true));
   m_Controls.showAliasesCheckBox->setChecked(m_Preferences->GetBool(SHOW_ALIASES, true));
   m_Controls.showDescriptionsCheckBox->setChecked(m_Preferences->GetBool(SHOW_DESCRIPTIONS, true));
   m_Controls.showAliasesInDescriptionCheckBox->setChecked(m_Preferences->GetBool(SHOW_ALIASES_IN_DESCRIPTION, true));
+  m_Controls.showPersistenceInDescriptionCheckBox->setChecked(m_Preferences->GetBool(SHOW_PERSISTENCE_IN_DESCRIPTION, true));
   m_Controls.enableDeveloperModeCheckBox->setChecked(m_Preferences->GetBool(DEVELOPER_MODE, false));
 }
diff --git a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertiesPreferencePage.h b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertiesPreferencePage.h
index d90a79facf..f482d6d1c3 100644
--- a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertiesPreferencePage.h
+++ b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertiesPreferencePage.h
@@ -1,54 +1,55 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef QmitkPropertiesPreferencePage_h
 #define QmitkPropertiesPreferencePage_h
 
 #include <berryIQtPreferencePage.h>
 #include <ui_QmitkPropertiesPreferencePage.h>
 
 class QmitkPropertiesPreferencePage : public QObject, public berry::IQtPreferencePage
 {
   Q_OBJECT
   Q_INTERFACES(berry::IPreferencePage)
 
 public:
   static const QString FILTER_PROPERTIES;
   static const QString SHOW_ALIASES;
   static const QString SHOW_DESCRIPTIONS;
   static const QString SHOW_ALIASES_IN_DESCRIPTION;
+  static const QString SHOW_PERSISTENCE_IN_DESCRIPTION;
   static const QString DEVELOPER_MODE;
 
   QmitkPropertiesPreferencePage();
   ~QmitkPropertiesPreferencePage();
 
   void CreateQtControl(QWidget* parent) override;
   QWidget* GetQtControl() const override;
   void Init(berry::IWorkbench::Pointer workbench) override;
   bool PerformOk() override;
   void PerformCancel() override;
   void Update() override;
 
 private slots:
   void OnShowDescriptionsStateChanged(int state);
 
 private:
   QWidget* m_Control;
   Ui::QmitkPropertiesPreferencePage m_Controls;
   berry::IPreferences::Pointer m_Preferences;
 };
 
 #endif
diff --git a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertiesPreferencePage.ui b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertiesPreferencePage.ui
index 318d3156ff..2732cacb72 100644
--- a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertiesPreferencePage.ui
+++ b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertiesPreferencePage.ui
@@ -1,130 +1,143 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkPropertiesPreferencePage</class>
  <widget class="QWidget" name="QmitkPropertiesPreferencePage">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>400</width>
     <height>577</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string/>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_5">
    <item>
     <widget class="QGroupBox" name="aliasesGroupBox">
      <property name="title">
       <string>Aliases</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_2">
       <item>
        <widget class="QCheckBox" name="showAliasesCheckBox">
         <property name="text">
          <string>Replace genuine property names by aliases</string>
         </property>
         <property name="checked">
          <bool>true</bool>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="descriptionsGroupBox">
      <property name="title">
       <string>Descriptions</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout">
       <item>
        <widget class="QCheckBox" name="showDescriptionsCheckBox">
         <property name="text">
          <string>Show descriptions</string>
         </property>
         <property name="checked">
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QCheckBox" name="showAliasesInDescriptionCheckBox">
         <property name="styleSheet">
          <string notr="true">margin-left: 18px;</string>
         </property>
         <property name="text">
          <string>Show aliases of genuine property names</string>
         </property>
         <property name="checked">
          <bool>true</bool>
         </property>
        </widget>
       </item>
+      <item>
+       <widget class="QCheckBox" name="showPersistenceInDescriptionCheckBox">
+        <property name="styleSheet">
+         <string notr="true">margin-left: 18px;</string>
+        </property>
+        <property name="text">
+         <string>Show persistence info</string>
+        </property>
+        <property name="checked">
+         <bool>true</bool>
+        </property>
+       </widget>
+      </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="filtersGroupBox">
      <property name="title">
       <string>Filters</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_3">
       <item>
        <widget class="QCheckBox" name="filterPropertiesCheckBox">
         <property name="text">
          <string>Only show filtered properties</string>
         </property>
         <property name="checked">
          <bool>true</bool>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="developerModeGroupBox">
      <property name="title">
       <string>Developer Mode</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_4">
       <item>
        <widget class="QCheckBox" name="enableDeveloperModeCheckBox">
         <property name="enabled">
          <bool>true</bool>
         </property>
         <property name="text">
          <string>Enabled</string>
         </property>
         <property name="checked">
          <bool>false</bool>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>204</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <tabstops>
   <tabstop>showAliasesCheckBox</tabstop>
   <tabstop>showDescriptionsCheckBox</tabstop>
  </tabstops>
  <resources/>
  <connections/>
 </ui>
diff --git a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyTreeView.cpp b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyTreeView.cpp
index 8aa4bcabb5..5398aa49cf 100644
--- a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyTreeView.cpp
+++ b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyTreeView.cpp
@@ -1,416 +1,460 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkGetPropertyService.h"
 #include "QmitkAddNewPropertyDialog.h"
 #include "QmitkPropertiesPreferencePage.h"
 #include "QmitkPropertyItemDelegate.h"
 #include "QmitkPropertyItemModel.h"
 #include "QmitkPropertyItemSortFilterProxyModel.h"
 #include "QmitkPropertyTreeView.h"
 #include <berryIBerryPreferences.h>
 #include <mitkIPropertyAliases.h>
 #include <mitkIPropertyDescriptions.h>
+#include <mitkIPropertyPersistence.h>
 #include <QmitkRenderWindow.h>
 #include <QPainter>
 #include <memory>
 
 const std::string QmitkPropertyTreeView::VIEW_ID = "org.mitk.views.properties";
 
 QmitkPropertyTreeView::QmitkPropertyTreeView()
-  : m_Parent(NULL),
+  : m_Parent(nullptr),
     m_PropertyNameChangedTag(0),
-    m_PropertyAliases(NULL),
-    m_PropertyDescriptions(NULL),
+    m_PropertyAliases(nullptr),
+    m_PropertyDescriptions(nullptr),
+    m_PropertyPersistence(nullptr),
     m_ShowAliasesInDescription(true),
+    m_ShowPersistenceInDescription(true),
     m_DeveloperMode(false),
-    m_ProxyModel(NULL),
-    m_Model(NULL),
-    m_Delegate(NULL),
-    m_Renderer(NULL)
+    m_ProxyModel(nullptr),
+    m_Model(nullptr),
+    m_Delegate(nullptr),
+    m_Renderer(nullptr)
 {
 }
 
 QmitkPropertyTreeView::~QmitkPropertyTreeView()
 {
 }
 
 void QmitkPropertyTreeView::CreateQtPartControl(QWidget* parent)
 {
   m_Parent = parent;
 
   m_Controls.setupUi(parent);
 
   m_Controls.propertyListComboBox->addItem("Data node: common");
 
   mitk::IRenderWindowPart* renderWindowPart = this->GetRenderWindowPart();
 
   if (renderWindowPart != NULL)
   {
     QHash<QString, QmitkRenderWindow*> renderWindows = renderWindowPart->GetQmitkRenderWindows();
 
     Q_FOREACH(QString renderWindow, renderWindows.keys())
     {
       m_Controls.propertyListComboBox->addItem(QString("Data node: ") + renderWindow);
     }
   }
 
   m_Controls.propertyListComboBox->addItem("Base data");
 
   m_Controls.newButton->setEnabled(false);
 
   m_Controls.description->hide();
   m_Controls.propertyListLabel->hide();
   m_Controls.propertyListComboBox->hide();
   m_Controls.newButton->hide();
 
   m_ProxyModel = new QmitkPropertyItemSortFilterProxyModel(m_Controls.treeView);
   m_Model = new QmitkPropertyItemModel(m_ProxyModel);
 
   m_ProxyModel->setSourceModel(m_Model);
   m_ProxyModel->setFilterCaseSensitivity(Qt::CaseInsensitive);
   m_ProxyModel->setSortCaseSensitivity(Qt::CaseInsensitive);
   m_ProxyModel->setDynamicSortFilter(true);
 
   m_Delegate = new QmitkPropertyItemDelegate(m_Controls.treeView);
 
 #if QT_VERSION >= QT_VERSION_CHECK(5, 2, 0)
   m_Controls.filterLineEdit->setClearButtonEnabled(true);
 #endif
 
   m_Controls.treeView->setItemDelegateForColumn(1, m_Delegate);
   m_Controls.treeView->setModel(m_ProxyModel);
   m_Controls.treeView->setColumnWidth(0, 160);
   m_Controls.treeView->sortByColumn(0, Qt::AscendingOrder);
   m_Controls.treeView->setSelectionBehavior(QAbstractItemView::SelectRows);
   m_Controls.treeView->setSelectionMode(QAbstractItemView::SingleSelection);
   m_Controls.treeView->setEditTriggers(QAbstractItemView::SelectedClicked | QAbstractItemView::DoubleClicked);
 
   connect(m_Controls.filterLineEdit, SIGNAL(textChanged(const QString&)), this, SLOT(OnFilterTextChanged(const QString&)));
   connect(m_Controls.propertyListComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnPropertyListChanged(int)));
   connect(m_Controls.newButton, SIGNAL(clicked()), this, SLOT(OnAddNewProperty()));
   connect(m_Controls.treeView->selectionModel(), SIGNAL(currentRowChanged(const QModelIndex&, const QModelIndex&)), this, SLOT(OnCurrentRowChanged(const QModelIndex&, const QModelIndex&)));
   connect(m_Model, SIGNAL(modelReset()), this, SLOT(OnModelReset()));
 }
 
 QString QmitkPropertyTreeView::GetPropertyNameOrAlias(const QModelIndex& index)
 {
   QString propertyName;
 
   if (index.isValid())
   {
     QModelIndex current = index;
 
     while (current.isValid())
     {
       QString name = m_ProxyModel->data(m_ProxyModel->index(current.row(), 0, current.parent())).toString();
 
       propertyName.prepend(propertyName.isEmpty()
         ? name
         : name.append('.'));
 
       current = current.parent();
     }
   }
 
   return propertyName;
 }
 
 void QmitkPropertyTreeView::OnCurrentRowChanged(const QModelIndex& current, const QModelIndex&)
 {
-  if (m_PropertyDescriptions != NULL && current.isValid())
+  if (m_PropertyDescriptions != nullptr && current.isValid())
   {
     QString name = this->GetPropertyNameOrAlias(current);
 
     if (!name.isEmpty())
     {
       QString alias;
       bool isTrueName = true;
 
-      if (m_PropertyAliases != NULL)
+      if (m_PropertyAliases != nullptr)
       {
         std::string trueName = m_PropertyAliases->GetPropertyName(name.toStdString());
 
         if (trueName.empty() && !m_SelectionClassName.empty())
           trueName = m_PropertyAliases->GetPropertyName(name.toStdString(), m_SelectionClassName);
 
         if (!trueName.empty())
         {
           alias = name;
           name = QString::fromStdString(trueName);
           isTrueName = false;
         }
       }
 
       QString description = QString::fromStdString(m_PropertyDescriptions->GetDescription(name.toStdString()));
       std::vector<std::string> aliases;
 
-      if (!isTrueName && m_PropertyAliases != NULL)
+      if (!isTrueName && m_PropertyAliases != nullptr)
       {
         aliases = m_PropertyAliases->GetAliases(name.toStdString(), m_SelectionClassName);
 
         if (aliases.empty() && !m_SelectionClassName.empty())
           aliases = m_PropertyAliases->GetAliases(name.toStdString());
       }
 
-      if (!description.isEmpty() || !aliases.empty())
+      bool isPersistent = false;
+      // QString persistenceKey;
+
+      if (m_PropertyPersistence != nullptr)
+      {
+        isPersistent = m_PropertyPersistence->HasInfo(name.toStdString());
+
+        /*if (isPersistent)
+        {
+          persistenceKey = QString::fromStdString(m_PropertyPersistence->GetInfo(name.toStdString())->GetKey());
+
+          if (persistenceKey.isEmpty())
+            persistenceKey = name;
+        }*/
+      }
+
+      if (!description.isEmpty() || !aliases.empty() || isPersistent)
       {
         QString customizedDescription;
 
         if (m_ShowAliasesInDescription && !aliases.empty())
         {
           customizedDescription = "<h3 style=\"margin-bottom:0\">" + name + "</h3>";
 
           std::size_t numAliases = aliases.size();
           std::size_t lastAlias = numAliases - 1;
 
           for (std::size_t i = 0; i < numAliases; ++i)
           {
             customizedDescription += i != lastAlias
               ? "<h5 style=\"margin-top:0;margin-bottom:0\">"
               : "<h5 style=\"margin-top:0;margin-bottom:10px\">";
 
             customizedDescription += QString::fromStdString(aliases[i]) + "</h5>";
           }
         }
         else
         {
           customizedDescription = "<h3 style=\"margin-bottom:10px\">" + name + "</h3>";
         }
 
         if (!description.isEmpty())
-          customizedDescription += description;
+          customizedDescription += "<p>" + description + "</p>";
+
+        if (!aliases.empty() || isPersistent)
+        {
+          customizedDescription += "<div align=\"right\">";
+
+          if (!aliases.empty())
+          {
+            customizedDescription += aliases.size() > 1
+              ? "<img height=\"32\" src=\":/org_mitk_icons/icons/awesome/scalable/tags.svg\"/>"
+              : "<img height=\"32\" src=\":/org_mitk_icons/icons/awesome/scalable/tag.svg\"/>";
+          }
+
+          if (isPersistent)
+            customizedDescription += "<img height=\"32\" src=\":/org_mitk_icons/icons/awesome/scalable/actions/document-save.svg\"/>";
+
+          customizedDescription += "</div>";
+        }
 
         m_Controls.description->setText(customizedDescription);
         m_Controls.description->show();
 
         return;
       }
     }
   }
 
   m_Controls.description->hide();
 }
 
 void QmitkPropertyTreeView::OnFilterTextChanged(const QString& filter)
 {
   m_ProxyModel->setFilterWildcard(filter);
 
   if (filter.isEmpty())
     m_Controls.treeView->collapseAll();
   else
     m_Controls.treeView->expandAll();
 }
 
 void QmitkPropertyTreeView::OnModelReset()
 {
   m_Controls.description->hide();
 }
 
 void QmitkPropertyTreeView::OnPreferencesChanged(const berry::IBerryPreferences* preferences)
 {
   bool showAliases = preferences->GetBool(QmitkPropertiesPreferencePage::SHOW_ALIASES, true);
   bool showDescriptions = preferences->GetBool(QmitkPropertiesPreferencePage::SHOW_DESCRIPTIONS, true);
   bool showAliasesInDescription = preferences->GetBool(QmitkPropertiesPreferencePage::SHOW_ALIASES_IN_DESCRIPTION, true);
+  bool showPersistenceInDescription = preferences->GetBool(QmitkPropertiesPreferencePage::SHOW_PERSISTENCE_IN_DESCRIPTION, true);
   bool developerMode = preferences->GetBool(QmitkPropertiesPreferencePage::DEVELOPER_MODE, false);
 
   bool updateAliases = showAliases != (m_PropertyAliases != NULL);
   bool updateDescriptions = showDescriptions != (m_PropertyDescriptions != NULL);
   bool updateAliasesInDescription = showAliasesInDescription != m_ShowAliasesInDescription;
+  bool updatePersistenceInDescription = showPersistenceInDescription != m_ShowPersistenceInDescription;
   bool updateDeveloperMode = developerMode != m_DeveloperMode;
 
   if (updateAliases)
     m_PropertyAliases = showAliases
       ? mitk::GetPropertyService<mitk::IPropertyAliases>()
-      : NULL;
+      : nullptr;
 
   if (updateDescriptions)
     m_PropertyDescriptions = showDescriptions
       ? mitk::GetPropertyService<mitk::IPropertyDescriptions>()
-      : NULL;
+      : nullptr;
+
+  if (showPersistenceInDescription)
+    m_PropertyPersistence = mitk::GetPropertyService<mitk::IPropertyPersistence>();
 
   if (updateAliasesInDescription)
     m_ShowAliasesInDescription = showAliasesInDescription;
 
-  if (updateDescriptions || updateAliasesInDescription)
+  if (updatePersistenceInDescription)
+    m_ShowPersistenceInDescription = showPersistenceInDescription;
+
+  if (updateDescriptions || updateAliasesInDescription || updatePersistenceInDescription)
   {
     QModelIndexList selection = m_Controls.treeView->selectionModel()->selectedRows();
 
     if (!selection.isEmpty())
       this->OnCurrentRowChanged(selection[0], selection[0]);
   }
 
   if (updateDeveloperMode)
   {
     m_DeveloperMode = developerMode;
 
     if (!developerMode)
       m_Controls.propertyListComboBox->setCurrentIndex(0);
 
     m_Controls.propertyListLabel->setVisible(developerMode);
     m_Controls.propertyListComboBox->setVisible(developerMode);
     m_Controls.newButton->setVisible(developerMode);
   }
 
   m_Model->OnPreferencesChanged(preferences);
 }
 
 void QmitkPropertyTreeView::OnPropertyNameChanged(const itk::EventObject&)
 {
   mitk::PropertyList* propertyList = m_Model->GetPropertyList();
 
   if (propertyList != NULL)
   {
     mitk::BaseProperty* nameProperty = propertyList->GetProperty("name");
 
     if (nameProperty != NULL)
     {
       QString partName = "Properties (";
       partName.append(QString::fromStdString(nameProperty->GetValueAsString())).append(')');
       this->SetPartName(partName);
     }
   }
 }
 
 void QmitkPropertyTreeView::OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes)
 {
   mitk::PropertyList* propertyList = m_Model->GetPropertyList();
 
   if (propertyList != NULL)
   {
     mitk::BaseProperty* nameProperty = propertyList->GetProperty("name");
 
     if (nameProperty != NULL)
       nameProperty->RemoveObserver(m_PropertyNameChangedTag);
 
     m_PropertyNameChangedTag = 0;
   }
 
   if (nodes.empty() || nodes.front().IsNull())
   {
     m_SelectedNode = NULL;
 
     this->SetPartName("Properties");
     m_Model->SetPropertyList(NULL);
     m_Delegate->SetPropertyList(NULL);
 
     m_Controls.newButton->setEnabled(false);
   }
   else
   {
     m_SelectedNode = nodes.front();
 
     QString selectionClassName = m_SelectedNode->GetData() != NULL
       ? m_SelectedNode->GetData()->GetNameOfClass()
       : "";
 
     m_SelectionClassName = selectionClassName.toStdString();
 
     mitk::PropertyList::Pointer propertyList;
 
     if (m_Renderer == NULL && m_Controls.propertyListComboBox->currentText() == "Base data")
     {
       propertyList = m_SelectedNode->GetData() != NULL
         ? m_SelectedNode->GetData()->GetPropertyList()
         : NULL;
     }
     else
     {
       propertyList = m_SelectedNode->GetPropertyList(m_Renderer);
     }
 
     m_Model->SetPropertyList(propertyList, selectionClassName);
     m_Delegate->SetPropertyList(propertyList);
 
     OnPropertyNameChanged(itk::ModifiedEvent());
 
     mitk::BaseProperty* nameProperty = m_SelectedNode->GetProperty("name");
 
     if (nameProperty != NULL)
     {
       itk::ReceptorMemberCommand<QmitkPropertyTreeView>::Pointer command = itk::ReceptorMemberCommand<QmitkPropertyTreeView>::New();
       command->SetCallbackFunction(this, &QmitkPropertyTreeView::OnPropertyNameChanged);
       m_PropertyNameChangedTag = nameProperty->AddObserver(itk::ModifiedEvent(), command);
     }
 
     m_Controls.newButton->setEnabled(true);
   }
 
   if (!m_ProxyModel->filterRegExp().isEmpty())
     m_Controls.treeView->expandAll();
 }
 
 void QmitkPropertyTreeView::SetFocus()
 {
   m_Controls.filterLineEdit->setFocus();
 }
 
 void QmitkPropertyTreeView::RenderWindowPartActivated(mitk::IRenderWindowPart* /*renderWindowPart*/)
 {
   if (m_Controls.propertyListComboBox->count() == 2)
   {
     QHash<QString, QmitkRenderWindow*> renderWindows = this->GetRenderWindowPart()->GetQmitkRenderWindows();
 
     Q_FOREACH(QString renderWindow, renderWindows.keys())
     {
       m_Controls.propertyListComboBox->insertItem(m_Controls.propertyListComboBox->count() - 1, QString("Data node: ") + renderWindow);
     }
   }
 }
 
 void QmitkPropertyTreeView::RenderWindowPartDeactivated(mitk::IRenderWindowPart*)
 {
   if (m_Controls.propertyListComboBox->count() > 2)
   {
     m_Controls.propertyListComboBox->clear();
     m_Controls.propertyListComboBox->addItem("Data node: common");
     m_Controls.propertyListComboBox->addItem("Base data");
   }
 }
 
 void QmitkPropertyTreeView::OnPropertyListChanged(int index)
 {
   if (index == -1)
     return;
 
   QString renderer = m_Controls.propertyListComboBox->itemText(index);
 
   if (renderer.startsWith("Data node: "))
     renderer = QString::fromStdString(renderer.toStdString().substr(11));
 
   m_Renderer = renderer != "common" && renderer != "Base data"
     ? this->GetRenderWindowPart()->GetQmitkRenderWindow(renderer)->GetRenderer()
     : NULL;
 
   QList<mitk::DataNode::Pointer> nodes;
 
   if (m_SelectedNode.IsNotNull())
     nodes << m_SelectedNode;
 
   berry::IWorkbenchPart::Pointer workbenchPart;
 
   this->OnSelectionChanged(workbenchPart, nodes);
 }
 
 void QmitkPropertyTreeView::OnAddNewProperty()
 {
   std::unique_ptr<QmitkAddNewPropertyDialog> dialog(m_Controls.propertyListComboBox->currentText() != "Base data"
       ? new QmitkAddNewPropertyDialog(m_SelectedNode, m_Renderer, m_Parent)
       : new QmitkAddNewPropertyDialog(m_SelectedNode->GetData()));
 
   if (dialog->exec() == QDialog::Accepted)
     this->m_Model->Update();
 }
diff --git a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyTreeView.h b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyTreeView.h
index 500f81e06a..d1f2f2eaf9 100644
--- a/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyTreeView.h
+++ b/Plugins/org.mitk.gui.qt.properties/src/internal/QmitkPropertyTreeView.h
@@ -1,84 +1,87 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef QmitkPropertyTreeView_h
 #define QmitkPropertyTreeView_h
 
 #include <mitkDataNode.h>
 #include <mitkIRenderWindowPartListener.h>
 #include <QmitkAbstractView.h>
 #include <ui_QmitkPropertyTreeView.h>
 
 class QmitkPropertyItemDelegate;
 class QmitkPropertyItemModel;
 class QmitkPropertyItemSortFilterProxyModel;
 
 namespace mitk
 {
   class IPropertyAliases;
   class IPropertyDescriptions;
+  class IPropertyPersistence;
 }
 
 class QmitkPropertyTreeView : public QmitkAbstractView, public mitk::IRenderWindowPartListener
 {
   Q_OBJECT
 
 public:
   static const std::string VIEW_ID;
 
   berryObjectMacro(QmitkPropertyTreeView);
 
   QmitkPropertyTreeView();
   ~QmitkPropertyTreeView();
 
   void SetFocus() override;
 
   void RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart) override;
   void RenderWindowPartDeactivated(mitk::IRenderWindowPart*) override;
 
 protected:
   void CreateQtPartControl(QWidget* parent) override;
 
 private:
   QString GetPropertyNameOrAlias(const QModelIndex& index);
   void OnPreferencesChanged(const berry::IBerryPreferences* preferences) override;
   void OnPropertyNameChanged(const itk::EventObject& event);
   void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer>& nodes) override;
 
 private slots:
   void OnCurrentRowChanged(const QModelIndex& current, const QModelIndex& previous);
   void OnPropertyListChanged(int index);
   void OnAddNewProperty();
   void OnFilterTextChanged(const QString& filter);
   void OnModelReset();
 
 private:
   QWidget* m_Parent;
   unsigned long m_PropertyNameChangedTag;
   std::string m_SelectionClassName;
   mitk::IPropertyAliases* m_PropertyAliases;
   mitk::IPropertyDescriptions* m_PropertyDescriptions;
+  mitk::IPropertyPersistence* m_PropertyPersistence;
   bool m_ShowAliasesInDescription;
+  bool m_ShowPersistenceInDescription;
   bool m_DeveloperMode;
   Ui::QmitkPropertyTreeView m_Controls;
   QmitkPropertyItemSortFilterProxyModel* m_ProxyModel;
   QmitkPropertyItemModel* m_Model;
   QmitkPropertyItemDelegate* m_Delegate;
   mitk::DataNode::Pointer m_SelectedNode;
   mitk::BaseRenderer* m_Renderer;
 };
 
 #endif